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 *const opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *const opt_name_audio_channels[] = {"ac", NULL};
56 static const char *const opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *const opt_name_frame_rates[] = {"r", NULL};
58 static const char *const opt_name_max_frame_rates[] = {"fpsmax", NULL};
59 static const char *const opt_name_frame_sizes[] = {"s", NULL};
60 static const char *const opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
61 static const char *const opt_name_ts_scale[] = {"itsscale", NULL};
62 static const char *const opt_name_hwaccels[] = {"hwaccel", NULL};
63 static const char *const opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
64 static const char *const opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
65 static const char *const opt_name_autorotate[] = {"autorotate", NULL};
66 static const char *const opt_name_autoscale[] = {"autoscale", NULL};
67 static const char *const opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
68 static const char *const opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
69 static const char *const opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
70 static const char *const opt_name_sample_fmts[] = {"sample_fmt", NULL};
71 static const char *const opt_name_qscale[] = {"q", "qscale", NULL};
72 static const char *const opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
73 static const char *const opt_name_force_fps[] = {"force_fps", NULL};
74 static const char *const opt_name_frame_aspect_ratios[] = {"aspect", NULL};
75 static const char *const opt_name_rc_overrides[] = {"rc_override", NULL};
76 static const char *const opt_name_intra_matrices[] = {"intra_matrix", NULL};
77 static const char *const opt_name_inter_matrices[] = {"inter_matrix", NULL};
78 static const char *const opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
79 static const char *const opt_name_top_field_first[] = {"top", NULL};
80 static const char *const opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
81 static const char *const opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
82 static const char *const opt_name_copy_prior_start[] = {"copypriorss", NULL};
83 static const char *const opt_name_filters[] = {"filter", "af", "vf", NULL};
84 static const char *const opt_name_filter_scripts[] = {"filter_script", NULL};
85 static const char *const opt_name_reinit_filters[] = {"reinit_filter", NULL};
86 static const char *const opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
87 static const char *const opt_name_canvas_sizes[] = {"canvas_size", NULL};
88 static const char *const opt_name_pass[] = {"pass", NULL};
89 static const char *const opt_name_passlogfiles[] = {"passlogfile", NULL};
90 static const char *const opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
91 static const char *const opt_name_muxing_queue_data_threshold[] = {"muxing_queue_data_threshold", NULL};
92 static const char *const opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
93 static const char *const opt_name_apad[] = {"apad", NULL};
94 static const char *const opt_name_discard[] = {"discard", NULL};
95 static const char *const opt_name_disposition[] = {"disposition", NULL};
96 static const char *const opt_name_time_bases[] = {"time_base", NULL};
97 static const char *const opt_name_enc_time_bases[] = {"enc_time_base", NULL};
99 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
101 char namestr[128] = "";\
102 const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
103 for (i = 0; opt_name_##name[i]; i++)\
104 av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
105 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",\
106 namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
109 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
111 int i, ret, matches = 0;\
113 for (i = 0; i < o->nb_ ## name; i++) {\
114 char *spec = o->name[i].specifier;\
115 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
116 outvar = o->name[i].u.type;\
123 WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
126 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
129 for (i = 0; i < o->nb_ ## name; i++) {\
130 char *spec = o->name[i].specifier;\
131 if (!strcmp(spec, mediatype))\
132 outvar = o->name[i].u.type;\
136 const HWAccel hwaccels[] = {
137 #if CONFIG_VIDEOTOOLBOX
138 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
141 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
145 HWDevice *filter_hw_device;
147 char *vstats_filename;
150 float audio_drift_threshold = 0.1;
151 float dts_delta_threshold = 10;
152 float dts_error_threshold = 3600*30;
154 int audio_volume = 256;
155 int audio_sync_method = 0;
156 int video_sync_method = VSYNC_AUTO;
157 float frame_drop_threshold = 0;
158 int do_deinterlace = 0;
159 int do_benchmark = 0;
160 int do_benchmark_all = 0;
164 int start_at_zero = 0;
167 int exit_on_error = 0;
168 int abort_on_flags = 0;
169 int print_stats = -1;
171 int stdin_interaction = 1;
172 int frame_bits_per_raw_sample = 0;
173 float max_error_rate = 2.0/3;
174 int filter_nbthreads = 0;
175 int filter_complex_nbthreads = 0;
176 int vstats_version = 2;
177 int auto_conversion_filters = 1;
178 int64_t stats_period = 500000;
181 static int intra_only = 0;
182 static int file_overwrite = 0;
183 static int no_file_overwrite = 0;
184 static int do_psnr = 0;
185 static int input_sync;
186 static int input_stream_potentially_available = 0;
187 static int ignore_unknown_streams = 0;
188 static int copy_unknown_streams = 0;
189 static int find_stream_info = 1;
191 static void uninit_options(OptionsContext *o)
193 const OptionDef *po = options;
196 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
198 void *dst = (uint8_t*)o + po->u.off;
200 if (po->flags & OPT_SPEC) {
201 SpecifierOpt **so = dst;
202 int i, *count = (int*)(so + 1);
203 for (i = 0; i < *count; i++) {
204 av_freep(&(*so)[i].specifier);
205 if (po->flags & OPT_STRING)
206 av_freep(&(*so)[i].u.str);
210 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
215 for (i = 0; i < o->nb_stream_maps; i++)
216 av_freep(&o->stream_maps[i].linklabel);
217 av_freep(&o->stream_maps);
218 av_freep(&o->audio_channel_maps);
219 av_freep(&o->streamid_map);
220 av_freep(&o->attachments);
223 static void init_options(OptionsContext *o)
225 memset(o, 0, sizeof(*o));
227 o->stop_time = INT64_MAX;
228 o->mux_max_delay = 0.7;
229 o->start_time = AV_NOPTS_VALUE;
230 o->start_time_eof = AV_NOPTS_VALUE;
231 o->recording_time = INT64_MAX;
232 o->limit_filesize = UINT64_MAX;
233 o->chapters_input_file = INT_MAX;
234 o->accurate_seek = 1;
235 o->thread_queue_size = -1;
238 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
240 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
242 printf("Hardware acceleration methods:\n");
243 while ((type = av_hwdevice_iterate_types(type)) !=
244 AV_HWDEVICE_TYPE_NONE)
245 printf("%s\n", av_hwdevice_get_type_name(type));
250 /* return a copy of the input with the stream specifiers removed from the keys */
251 static AVDictionary *strip_specifiers(AVDictionary *dict)
253 AVDictionaryEntry *e = NULL;
254 AVDictionary *ret = NULL;
256 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
257 char *p = strchr(e->key, ':');
261 av_dict_set(&ret, e->key, e->value, 0);
268 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
270 static const AVOption opts[] = {
271 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
272 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
273 { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
276 static const AVClass class = {
278 .item_name = av_default_item_name,
280 .version = LIBAVUTIL_VERSION_INT,
282 const AVClass *pclass = &class;
284 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
287 static int opt_stats_period(void *optctx, const char *opt, const char *arg)
289 int64_t user_stats_period = parse_time_or_die(opt, arg, 1);
291 if (user_stats_period <= 0) {
292 av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
293 return AVERROR(EINVAL);
296 stats_period = user_stats_period;
297 av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
302 static int opt_sameq(void *optctx, const char *opt, const char *arg)
304 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
305 "If you are looking for an option to preserve the quality (which is not "
306 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
308 return AVERROR(EINVAL);
311 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
313 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
314 return opt_default(optctx, "channel", arg);
317 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
319 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
320 return opt_default(optctx, "standard", arg);
323 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
326 return parse_option(o, "codec:a", arg, options);
329 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
331 OptionsContext *o = optctx;
332 return parse_option(o, "codec:v", arg, options);
335 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
337 OptionsContext *o = optctx;
338 return parse_option(o, "codec:s", arg, options);
341 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
343 OptionsContext *o = optctx;
344 return parse_option(o, "codec:d", arg, options);
347 static int opt_map(void *optctx, const char *opt, const char *arg)
349 OptionsContext *o = optctx;
351 int i, negative = 0, file_idx, disabled = 0;
352 int sync_file_idx = -1, sync_stream_idx = 0;
361 map = av_strdup(arg);
363 return AVERROR(ENOMEM);
365 /* parse sync stream first, just pick first matching stream */
366 if (sync = strchr(map, ',')) {
368 sync_file_idx = strtol(sync + 1, &sync, 0);
369 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
370 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
375 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
376 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
377 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
381 if (i == input_files[sync_file_idx]->nb_streams) {
382 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
383 "match any streams.\n", arg);
386 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
387 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
395 /* this mapping refers to lavfi output */
396 const char *c = map + 1;
397 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
398 m = &o->stream_maps[o->nb_stream_maps - 1];
399 m->linklabel = av_get_token(&c, "]");
401 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
405 if (allow_unused = strchr(map, '?'))
407 file_idx = strtol(map, &p, 0);
408 if (file_idx >= nb_input_files || file_idx < 0) {
409 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
413 /* disable some already defined maps */
414 for (i = 0; i < o->nb_stream_maps; i++) {
415 m = &o->stream_maps[i];
416 if (file_idx == m->file_index &&
417 check_stream_specifier(input_files[m->file_index]->ctx,
418 input_files[m->file_index]->ctx->streams[m->stream_index],
419 *p == ':' ? p + 1 : p) > 0)
423 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
424 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
425 *p == ':' ? p + 1 : p) <= 0)
427 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
431 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
432 m = &o->stream_maps[o->nb_stream_maps - 1];
434 m->file_index = file_idx;
437 if (sync_file_idx >= 0) {
438 m->sync_file_index = sync_file_idx;
439 m->sync_stream_index = sync_stream_idx;
441 m->sync_file_index = file_idx;
442 m->sync_stream_index = i;
449 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
450 } else if (disabled) {
451 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
452 "To ignore this, add a trailing '?' to the map.\n", arg);
455 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
456 "To ignore this, add a trailing '?' to the map.\n", arg);
465 static int opt_attach(void *optctx, const char *opt, const char *arg)
467 OptionsContext *o = optctx;
468 GROW_ARRAY(o->attachments, o->nb_attachments);
469 o->attachments[o->nb_attachments - 1] = arg;
473 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
475 OptionsContext *o = optctx;
481 mapchan = av_strdup(arg);
483 return AVERROR(ENOMEM);
485 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
486 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
488 /* muted channel syntax */
489 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
490 if ((n == 1 || n == 3) && m->channel_idx == -1) {
491 m->file_idx = m->stream_idx = -1;
493 m->ofile_idx = m->ostream_idx = -1;
499 n = sscanf(arg, "%d.%d.%d:%d.%d",
500 &m->file_idx, &m->stream_idx, &m->channel_idx,
501 &m->ofile_idx, &m->ostream_idx);
503 if (n != 3 && n != 5) {
504 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
505 "[file.stream.channel|-1][:syncfile:syncstream]\n");
509 if (n != 5) // only file.stream.channel specified
510 m->ofile_idx = m->ostream_idx = -1;
513 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
514 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
518 if (m->stream_idx < 0 ||
519 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
520 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
521 m->file_idx, m->stream_idx);
524 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
525 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
526 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
527 m->file_idx, m->stream_idx);
530 /* allow trailing ? to map_channel */
531 if (allow_unused = strchr(mapchan, '?'))
533 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
534 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
536 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
537 m->file_idx, m->stream_idx, m->channel_idx);
539 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
540 "To ignore this, add a trailing '?' to the map_channel.\n",
541 m->file_idx, m->stream_idx, m->channel_idx);
550 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
552 av_free(sdp_filename);
553 sdp_filename = av_strdup(arg);
558 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
560 const char *prefix = "vaapi:";
563 tmp = av_asprintf("%s%s", prefix, arg);
565 return AVERROR(ENOMEM);
566 err = hw_device_init_from_string(tmp, NULL);
572 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
574 if (!strcmp(arg, "list")) {
575 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
576 printf("Supported hardware device types:\n");
577 while ((type = av_hwdevice_iterate_types(type)) !=
578 AV_HWDEVICE_TYPE_NONE)
579 printf("%s\n", av_hwdevice_get_type_name(type));
583 return hw_device_init_from_string(arg, NULL);
587 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
589 if (filter_hw_device) {
590 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
591 return AVERROR(EINVAL);
593 filter_hw_device = hw_device_get_by_name(arg);
594 if (!filter_hw_device) {
595 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
596 return AVERROR(EINVAL);
602 * Parse a metadata specifier passed as 'arg' parameter.
603 * @param arg metadata string to parse
604 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
605 * @param index for type c/p, chapter/program index is written here
606 * @param stream_spec for type s, the stream specifier is written here
608 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
616 if (*(++arg) && *arg != ':') {
617 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
620 *stream_spec = *arg == ':' ? arg + 1 : "";
625 *index = strtol(++arg, NULL, 0);
628 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
635 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
637 AVDictionary **meta_in = NULL;
638 AVDictionary **meta_out = NULL;
640 char type_in, type_out;
641 const char *istream_spec = NULL, *ostream_spec = NULL;
642 int idx_in = 0, idx_out = 0;
644 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
645 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
648 if (type_out == 'g' || !*outspec)
649 o->metadata_global_manual = 1;
650 if (type_out == 's' || !*outspec)
651 o->metadata_streams_manual = 1;
652 if (type_out == 'c' || !*outspec)
653 o->metadata_chapters_manual = 1;
657 if (type_in == 'g' || type_out == 'g')
658 o->metadata_global_manual = 1;
659 if (type_in == 's' || type_out == 's')
660 o->metadata_streams_manual = 1;
661 if (type_in == 'c' || type_out == 'c')
662 o->metadata_chapters_manual = 1;
664 /* ic is NULL when just disabling automatic mappings */
668 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
669 if ((index) < 0 || (index) >= (nb_elems)) {\
670 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
675 #define SET_DICT(type, meta, context, index)\
678 meta = &context->metadata;\
681 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
682 meta = &context->chapters[index]->metadata;\
685 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
686 meta = &context->programs[index]->metadata;\
689 break; /* handled separately below */ \
690 default: av_assert0(0);\
693 SET_DICT(type_in, meta_in, ic, idx_in);
694 SET_DICT(type_out, meta_out, oc, idx_out);
696 /* for input streams choose first matching stream */
697 if (type_in == 's') {
698 for (i = 0; i < ic->nb_streams; i++) {
699 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
700 meta_in = &ic->streams[i]->metadata;
706 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
711 if (type_out == 's') {
712 for (i = 0; i < oc->nb_streams; i++) {
713 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
714 meta_out = &oc->streams[i]->metadata;
715 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
720 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
725 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
727 OptionsContext *o = optctx;
729 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
730 struct tm time = *gmtime((time_t*)&recording_timestamp);
731 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
733 parse_option(o, "metadata", buf, options);
735 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
736 "tag instead.\n", opt);
740 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
742 const AVCodecDescriptor *desc;
743 const char *codec_string = encoder ? "encoder" : "decoder";
747 avcodec_find_encoder_by_name(name) :
748 avcodec_find_decoder_by_name(name);
750 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
751 codec = encoder ? avcodec_find_encoder(desc->id) :
752 avcodec_find_decoder(desc->id);
754 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
755 codec_string, codec->name, desc->name);
759 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
762 if (codec->type != type) {
763 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
769 static const AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
771 char *codec_name = NULL;
773 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
775 const AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
776 st->codecpar->codec_id = codec->id;
779 return avcodec_find_decoder(st->codecpar->codec_id);
782 /* Add all the streams from the given input file to the global
783 * list of input streams. */
784 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
788 for (i = 0; i < ic->nb_streams; i++) {
789 AVStream *st = ic->streams[i];
790 AVCodecParameters *par = st->codecpar;
791 InputStream *ist = av_mallocz(sizeof(*ist));
792 char *framerate = NULL, *hwaccel_device = NULL;
793 const char *hwaccel = NULL;
794 char *hwaccel_output_format = NULL;
795 char *codec_tag = NULL;
797 char *discard_str = NULL;
798 const AVClass *cc = avcodec_get_class();
799 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
804 GROW_ARRAY(input_streams, nb_input_streams);
805 input_streams[nb_input_streams - 1] = ist;
808 ist->file_index = nb_input_files;
810 st->discard = AVDISCARD_ALL;
812 ist->min_pts = INT64_MAX;
813 ist->max_pts = INT64_MIN;
816 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
819 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
821 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
823 uint32_t tag = strtol(codec_tag, &next, 0);
825 tag = AV_RL32(codec_tag);
826 st->codecpar->codec_tag = tag;
829 ist->dec = choose_decoder(o, ic, st);
830 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
832 ist->reinit_filters = -1;
833 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
835 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
836 ist->user_set_discard = AVDISCARD_NONE;
838 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
839 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
840 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
841 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
842 ist->user_set_discard = AVDISCARD_ALL;
844 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
845 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
850 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
852 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
854 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
858 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
860 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
865 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
867 switch (par->codec_type) {
868 case AVMEDIA_TYPE_VIDEO:
870 ist->dec = avcodec_find_decoder(par->codec_id);
872 // avformat_find_stream_info() doesn't set this for us anymore.
873 ist->dec_ctx->framerate = st->avg_frame_rate;
875 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
876 if (framerate && av_parse_video_rate(&ist->framerate,
878 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
883 ist->top_field_first = -1;
884 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
886 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
887 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
888 hwaccel_output_format, ic, st);
890 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
891 av_log(NULL, AV_LOG_WARNING,
892 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
893 "with old commandlines. This behaviour is DEPRECATED and will be removed "
894 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
895 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
896 } else if (hwaccel_output_format) {
897 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
898 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
899 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
900 "format: %s", hwaccel_output_format);
903 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
907 // The NVDEC hwaccels use a CUDA device, so remap the name here.
908 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
911 if (!strcmp(hwaccel, "none"))
912 ist->hwaccel_id = HWACCEL_NONE;
913 else if (!strcmp(hwaccel, "auto"))
914 ist->hwaccel_id = HWACCEL_AUTO;
916 enum AVHWDeviceType type;
918 for (i = 0; hwaccels[i].name; i++) {
919 if (!strcmp(hwaccels[i].name, hwaccel)) {
920 ist->hwaccel_id = hwaccels[i].id;
925 if (!ist->hwaccel_id) {
926 type = av_hwdevice_find_type_by_name(hwaccel);
927 if (type != AV_HWDEVICE_TYPE_NONE) {
928 ist->hwaccel_id = HWACCEL_GENERIC;
929 ist->hwaccel_device_type = type;
933 if (!ist->hwaccel_id) {
934 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
936 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
937 type = AV_HWDEVICE_TYPE_NONE;
938 while ((type = av_hwdevice_iterate_types(type)) !=
939 AV_HWDEVICE_TYPE_NONE)
940 av_log(NULL, AV_LOG_FATAL, "%s ",
941 av_hwdevice_get_type_name(type));
942 av_log(NULL, AV_LOG_FATAL, "\n");
948 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
949 if (hwaccel_device) {
950 ist->hwaccel_device = av_strdup(hwaccel_device);
951 if (!ist->hwaccel_device)
955 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
958 case AVMEDIA_TYPE_AUDIO:
959 ist->guess_layout_max = INT_MAX;
960 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
961 guess_input_channel_layout(ist);
963 case AVMEDIA_TYPE_DATA:
964 case AVMEDIA_TYPE_SUBTITLE: {
965 char *canvas_size = NULL;
967 ist->dec = avcodec_find_decoder(par->codec_id);
968 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
969 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
971 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
972 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
977 case AVMEDIA_TYPE_ATTACHMENT:
978 case AVMEDIA_TYPE_UNKNOWN:
984 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
986 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
992 static void assert_file_overwrite(const char *filename)
994 const char *proto_name = avio_find_protocol_name(filename);
996 if (file_overwrite && no_file_overwrite) {
997 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
1001 if (!file_overwrite) {
1002 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
1003 if (stdin_interaction && !no_file_overwrite) {
1004 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
1007 signal(SIGINT, SIG_DFL);
1008 if (!read_yesno()) {
1009 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1015 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1021 if (proto_name && !strcmp(proto_name, "file")) {
1022 for (int i = 0; i < nb_input_files; i++) {
1023 InputFile *file = input_files[i];
1024 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1026 if (!strcmp(filename, file->ctx->url)) {
1027 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1028 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1035 static void dump_attachment(AVStream *st, const char *filename)
1038 AVIOContext *out = NULL;
1039 AVDictionaryEntry *e;
1041 if (!st->codecpar->extradata_size) {
1042 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1043 nb_input_files - 1, st->index);
1046 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1047 filename = e->value;
1049 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1050 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1054 assert_file_overwrite(filename);
1056 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1057 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1062 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1067 static int open_input_file(OptionsContext *o, const char *filename)
1070 AVFormatContext *ic;
1071 AVInputFormat *file_iformat = NULL;
1074 AVDictionary *unused_opts = NULL;
1075 AVDictionaryEntry *e = NULL;
1076 char * video_codec_name = NULL;
1077 char * audio_codec_name = NULL;
1078 char *subtitle_codec_name = NULL;
1079 char * data_codec_name = NULL;
1080 int scan_all_pmts_set = 0;
1082 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1083 o->stop_time = INT64_MAX;
1084 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1087 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1088 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1089 if (o->stop_time <= start_time) {
1090 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1093 o->recording_time = o->stop_time - start_time;
1098 if (!(file_iformat = av_find_input_format(o->format))) {
1099 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1104 if (!strcmp(filename, "-"))
1107 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1108 strcmp(filename, "/dev/stdin");
1110 /* get default parameters from command line */
1111 ic = avformat_alloc_context();
1113 print_error(filename, AVERROR(ENOMEM));
1116 if (o->nb_audio_sample_rate) {
1117 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1119 if (o->nb_audio_channels) {
1120 /* because we set audio_channels based on both the "ac" and
1121 * "channel_layout" options, we need to check that the specified
1122 * demuxer actually has the "channels" option before setting it */
1123 if (file_iformat && file_iformat->priv_class &&
1124 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1125 AV_OPT_SEARCH_FAKE_OBJ)) {
1126 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1129 if (o->nb_frame_rates) {
1130 /* set the format-level framerate option;
1131 * this is important for video grabbers, e.g. x11 */
1132 if (file_iformat && file_iformat->priv_class &&
1133 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1134 AV_OPT_SEARCH_FAKE_OBJ)) {
1135 av_dict_set(&o->g->format_opts, "framerate",
1136 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1139 if (o->nb_frame_sizes) {
1140 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1142 if (o->nb_frame_pix_fmts)
1143 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1145 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1146 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1147 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1148 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1150 if (video_codec_name)
1151 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1152 if (audio_codec_name)
1153 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1154 if (subtitle_codec_name)
1155 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1156 if (data_codec_name)
1157 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1159 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1160 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1161 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1162 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1164 ic->flags |= AVFMT_FLAG_NONBLOCK;
1166 ic->flags |= AVFMT_FLAG_BITEXACT;
1167 ic->interrupt_callback = int_cb;
1169 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1170 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1171 scan_all_pmts_set = 1;
1173 /* open the input file with generic avformat function */
1174 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1176 print_error(filename, err);
1177 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1178 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1181 if (scan_all_pmts_set)
1182 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1183 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1184 assert_avoptions(o->g->format_opts);
1186 /* apply forced codec ids */
1187 for (i = 0; i < ic->nb_streams; i++)
1188 choose_decoder(o, ic, ic->streams[i]);
1190 if (find_stream_info) {
1191 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1192 int orig_nb_streams = ic->nb_streams;
1194 /* If not enough info to get the stream parameters, we decode the
1195 first frames to get it. (used in mpeg case for example) */
1196 ret = avformat_find_stream_info(ic, opts);
1198 for (i = 0; i < orig_nb_streams; i++)
1199 av_dict_free(&opts[i]);
1203 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1204 if (ic->nb_streams == 0) {
1205 avformat_close_input(&ic);
1211 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1212 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1213 o->start_time_eof = AV_NOPTS_VALUE;
1216 if (o->start_time_eof != AV_NOPTS_VALUE) {
1217 if (o->start_time_eof >= 0) {
1218 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1221 if (ic->duration > 0) {
1222 o->start_time = o->start_time_eof + ic->duration;
1223 if (o->start_time < 0) {
1224 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1225 o->start_time = AV_NOPTS_VALUE;
1228 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1230 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1231 /* add the stream start time */
1232 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1233 timestamp += ic->start_time;
1235 /* if seeking requested, we execute it */
1236 if (o->start_time != AV_NOPTS_VALUE) {
1237 int64_t seek_timestamp = timestamp;
1239 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1240 int dts_heuristic = 0;
1241 for (i=0; i<ic->nb_streams; i++) {
1242 const AVCodecParameters *par = ic->streams[i]->codecpar;
1243 if (par->video_delay) {
1248 if (dts_heuristic) {
1249 seek_timestamp -= 3*AV_TIME_BASE / 23;
1252 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1254 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1255 filename, (double)timestamp / AV_TIME_BASE);
1259 /* update the current parameters so that they match the one of the input stream */
1260 add_input_streams(o, ic);
1262 /* dump the file content */
1263 av_dump_format(ic, nb_input_files, filename, 0);
1265 GROW_ARRAY(input_files, nb_input_files);
1266 f = av_mallocz(sizeof(*f));
1269 input_files[nb_input_files - 1] = f;
1272 f->ist_index = nb_input_streams - ic->nb_streams;
1273 f->start_time = o->start_time;
1274 f->recording_time = o->recording_time;
1275 f->input_ts_offset = o->input_ts_offset;
1276 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1277 f->nb_streams = ic->nb_streams;
1278 f->rate_emu = o->rate_emu;
1279 f->accurate_seek = o->accurate_seek;
1282 f->time_base = (AVRational){ 1, 1 };
1283 f->pkt = av_packet_alloc();
1287 f->thread_queue_size = o->thread_queue_size;
1290 /* check if all codec options have been used */
1291 unused_opts = strip_specifiers(o->g->codec_opts);
1292 for (i = f->ist_index; i < nb_input_streams; i++) {
1294 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1295 AV_DICT_IGNORE_SUFFIX)))
1296 av_dict_set(&unused_opts, e->key, NULL, 0);
1300 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1301 const AVClass *class = avcodec_get_class();
1302 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1303 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1304 const AVClass *fclass = avformat_get_class();
1305 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1306 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1307 if (!option || foption)
1311 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1312 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1313 "input file #%d (%s) is not a decoding option.\n", e->key,
1314 option->help ? option->help : "", nb_input_files - 1,
1319 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1320 "input file #%d (%s) has not been used for any stream. The most "
1321 "likely reason is either wrong type (e.g. a video option with "
1322 "no video streams) or that it is a private option of some decoder "
1323 "which was not actually used for any stream.\n", e->key,
1324 option->help ? option->help : "", nb_input_files - 1, filename);
1326 av_dict_free(&unused_opts);
1328 for (i = 0; i < o->nb_dump_attachment; i++) {
1331 for (j = 0; j < ic->nb_streams; j++) {
1332 AVStream *st = ic->streams[j];
1334 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1335 dump_attachment(st, o->dump_attachment[i].u.str);
1339 input_stream_potentially_available = 1;
1344 static uint8_t *get_line(AVIOContext *s)
1350 if (avio_open_dyn_buf(&line) < 0) {
1351 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1355 while ((c = avio_r8(s)) && c != '\n')
1358 avio_close_dyn_buf(line, &buf);
1363 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1366 char filename[1000];
1367 const char *base[3] = { getenv("AVCONV_DATADIR"),
1372 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1376 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1377 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1378 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1381 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1382 i != 1 ? "" : "/.avconv", preset_name);
1383 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1389 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1391 enum AVMediaType type = ost->st->codecpar->codec_type;
1392 char *codec_name = NULL;
1394 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1395 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1397 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1398 NULL, ost->st->codecpar->codec_type);
1399 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1401 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1402 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1403 "probably disabled. Please choose an encoder manually.\n",
1404 ost->file_index, ost->index, s->oformat->name,
1405 avcodec_get_name(ost->st->codecpar->codec_id));
1406 return AVERROR_ENCODER_NOT_FOUND;
1408 } else if (!strcmp(codec_name, "copy"))
1409 ost->stream_copy = 1;
1411 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1412 ost->st->codecpar->codec_id = ost->enc->id;
1414 ost->encoding_needed = !ost->stream_copy;
1416 /* no encoding supported for other media types */
1417 ost->stream_copy = 1;
1418 ost->encoding_needed = 0;
1424 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1427 AVStream *st = avformat_new_stream(oc, NULL);
1428 int idx = oc->nb_streams - 1, ret = 0;
1429 const char *bsfs = NULL, *time_base = NULL;
1430 char *next, *codec_tag = NULL;
1435 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1439 if (oc->nb_streams - 1 < o->nb_streamid_map)
1440 st->id = o->streamid_map[oc->nb_streams - 1];
1442 GROW_ARRAY(output_streams, nb_output_streams);
1443 if (!(ost = av_mallocz(sizeof(*ost))))
1445 output_streams[nb_output_streams - 1] = ost;
1447 ost->file_index = nb_output_files - 1;
1450 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1451 st->codecpar->codec_type = type;
1453 ret = choose_encoder(o, oc, ost);
1455 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1456 "%d:%d\n", ost->file_index, ost->index);
1460 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1461 if (!ost->enc_ctx) {
1462 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1465 ost->enc_ctx->codec_type = type;
1467 ost->ref_par = avcodec_parameters_alloc();
1468 if (!ost->ref_par) {
1469 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1474 AVIOContext *s = NULL;
1475 char *buf = NULL, *arg = NULL, *preset = NULL;
1477 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1479 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1481 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1482 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1485 if (!buf[0] || buf[0] == '#') {
1489 if (!(arg = strchr(buf, '='))) {
1490 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1494 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1496 } while (!s->eof_reached);
1500 av_log(NULL, AV_LOG_FATAL,
1501 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1502 preset, ost->file_index, ost->index);
1506 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1511 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1513 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1516 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1517 q.num <= 0 || q.den <= 0) {
1518 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1524 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1527 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1529 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1532 ost->enc_timebase = q;
1535 ost->max_frames = INT64_MAX;
1536 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1537 for (i = 0; i<o->nb_max_frames; i++) {
1538 char *p = o->max_frames[i].specifier;
1539 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1540 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1545 ost->copy_prior_start = -1;
1546 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1548 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1549 if (bsfs && *bsfs) {
1550 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1552 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1557 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1559 uint32_t tag = strtol(codec_tag, &next, 0);
1561 tag = AV_RL32(codec_tag);
1562 ost->st->codecpar->codec_tag =
1563 ost->enc_ctx->codec_tag = tag;
1566 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1568 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1569 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1572 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1573 ost->disposition = av_strdup(ost->disposition);
1575 ost->max_muxing_queue_size = 128;
1576 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1577 ost->max_muxing_queue_size *= sizeof(ost->pkt);
1579 ost->muxing_queue_data_size = 0;
1581 ost->muxing_queue_data_threshold = 50*1024*1024;
1582 MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1584 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1585 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1587 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1589 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1590 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1591 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1593 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1595 ost->source_index = source_index;
1596 if (source_index >= 0) {
1597 ost->sync_ist = input_streams[source_index];
1598 input_streams[source_index]->discard = 0;
1599 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1601 ost->last_mux_dts = AV_NOPTS_VALUE;
1603 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1604 if (!ost->muxing_queue)
1610 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1613 const char *p = str;
1620 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1627 /* read file contents into a string */
1628 static uint8_t *read_file(const char *filename)
1630 AVIOContext *pb = NULL;
1631 AVIOContext *dyn_buf = NULL;
1632 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1633 uint8_t buf[1024], *str;
1636 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1640 ret = avio_open_dyn_buf(&dyn_buf);
1645 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1646 avio_write(dyn_buf, buf, ret);
1647 avio_w8(dyn_buf, 0);
1650 ret = avio_close_dyn_buf(dyn_buf, &str);
1656 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1659 AVStream *st = ost->st;
1661 if (ost->filters_script && ost->filters) {
1662 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1663 "output stream #%d:%d.\n", nb_output_files, st->index);
1667 if (ost->filters_script)
1668 return read_file(ost->filters_script);
1669 else if (ost->filters)
1670 return av_strdup(ost->filters);
1672 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1676 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1677 const OutputStream *ost, enum AVMediaType type)
1679 if (ost->filters_script || ost->filters) {
1680 av_log(NULL, AV_LOG_ERROR,
1681 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1682 "Filtering and streamcopy cannot be used together.\n",
1683 ost->filters ? "Filtergraph" : "Filtergraph script",
1684 ost->filters ? ost->filters : ost->filters_script,
1685 av_get_media_type_string(type), ost->file_index, ost->index);
1690 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1694 AVCodecContext *video_enc;
1695 char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
1697 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1699 video_enc = ost->enc_ctx;
1701 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1702 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1703 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1707 MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1708 if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1709 av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1713 if (frame_rate && max_frame_rate) {
1714 av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1718 if ((frame_rate || max_frame_rate) &&
1719 video_sync_method == VSYNC_PASSTHROUGH)
1720 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1722 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1723 if (frame_aspect_ratio) {
1725 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1726 q.num <= 0 || q.den <= 0) {
1727 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1730 ost->frame_aspect_ratio = q;
1733 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1734 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1736 if (!ost->stream_copy) {
1737 const char *p = NULL;
1738 char *frame_size = NULL;
1739 char *frame_pix_fmt = NULL;
1740 char *intra_matrix = NULL, *inter_matrix = NULL;
1741 char *chroma_intra_matrix = NULL;
1745 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1746 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1747 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1751 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1752 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1753 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1754 ost->keep_pix_fmt = 1;
1755 if (!*++frame_pix_fmt)
1756 frame_pix_fmt = NULL;
1758 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1759 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1762 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1765 video_enc->gop_size = 0;
1766 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1768 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1769 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1772 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1774 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1775 if (chroma_intra_matrix) {
1776 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1778 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1781 video_enc->chroma_intra_matrix = p;
1782 parse_matrix_coeffs(p, chroma_intra_matrix);
1784 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1786 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1787 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1790 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1793 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1794 for (i = 0; p; i++) {
1796 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1798 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1801 video_enc->rc_override =
1802 av_realloc_array(video_enc->rc_override,
1803 i + 1, sizeof(RcOverride));
1804 if (!video_enc->rc_override) {
1805 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1808 video_enc->rc_override[i].start_frame = start;
1809 video_enc->rc_override[i].end_frame = end;
1811 video_enc->rc_override[i].qscale = q;
1812 video_enc->rc_override[i].quality_factor = 1.0;
1815 video_enc->rc_override[i].qscale = 0;
1816 video_enc->rc_override[i].quality_factor = -q/100.0;
1821 video_enc->rc_override_count = i;
1824 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1827 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1830 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1831 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1834 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1835 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1839 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1840 if (ost->logfile_prefix &&
1841 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1845 char logfilename[1024];
1848 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1849 ost->logfile_prefix ? ost->logfile_prefix :
1850 DEFAULT_PASS_LOGFILENAME_PREFIX,
1852 if (!strcmp(ost->enc->name, "libx264")) {
1853 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1855 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1856 char *logbuffer = read_file(logfilename);
1859 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1863 video_enc->stats_in = logbuffer;
1865 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1866 f = av_fopen_utf8(logfilename, "wb");
1868 av_log(NULL, AV_LOG_FATAL,
1869 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1870 logfilename, strerror(errno));
1878 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1879 if (ost->forced_keyframes)
1880 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1882 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1884 ost->top_field_first = -1;
1885 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1888 ost->avfilter = get_ost_filters(o, oc, ost);
1892 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1895 if (ost->stream_copy)
1896 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1901 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1906 AVCodecContext *audio_enc;
1908 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1911 audio_enc = ost->enc_ctx;
1912 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1914 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1915 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1917 if (!ost->stream_copy) {
1918 char *sample_fmt = NULL;
1920 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1922 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1924 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1925 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1929 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1931 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1932 ost->apad = av_strdup(ost->apad);
1934 ost->avfilter = get_ost_filters(o, oc, ost);
1938 /* check for channel mapping for this audio stream */
1939 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1940 AudioChannelMap *map = &o->audio_channel_maps[n];
1941 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1942 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1945 if (map->channel_idx == -1) {
1947 } else if (ost->source_index < 0) {
1948 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1949 ost->file_index, ost->st->index);
1952 ist = input_streams[ost->source_index];
1955 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1956 if (av_reallocp_array(&ost->audio_channels_map,
1957 ost->audio_channels_mapped + 1,
1958 sizeof(*ost->audio_channels_map)
1962 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1968 if (ost->stream_copy)
1969 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1974 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1978 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1979 if (!ost->stream_copy) {
1980 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1987 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1991 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1992 if (!ost->stream_copy) {
1993 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
2000 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2002 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2003 ost->stream_copy = 1;
2008 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2012 AVCodecContext *subtitle_enc;
2014 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2016 subtitle_enc = ost->enc_ctx;
2018 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2020 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2022 if (!ost->stream_copy) {
2023 char *frame_size = NULL;
2025 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2026 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2027 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2035 /* arg format is "output-stream-index:streamid-value". */
2036 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2038 OptionsContext *o = optctx;
2043 av_strlcpy(idx_str, arg, sizeof(idx_str));
2044 p = strchr(idx_str, ':');
2046 av_log(NULL, AV_LOG_FATAL,
2047 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2052 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2053 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2054 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2058 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2060 AVFormatContext *is = ifile->ctx;
2061 AVFormatContext *os = ofile->ctx;
2065 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2067 return AVERROR(ENOMEM);
2070 for (i = 0; i < is->nb_chapters; i++) {
2071 AVChapter *in_ch = is->chapters[i], *out_ch;
2072 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2073 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2074 AV_TIME_BASE_Q, in_ch->time_base);
2075 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2076 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2079 if (in_ch->end < ts_off)
2081 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2084 out_ch = av_mallocz(sizeof(AVChapter));
2086 return AVERROR(ENOMEM);
2088 out_ch->id = in_ch->id;
2089 out_ch->time_base = in_ch->time_base;
2090 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2091 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2094 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2096 os->chapters[os->nb_chapters++] = out_ch;
2101 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2102 AVFormatContext *oc)
2106 switch (ofilter->type) {
2107 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2108 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2110 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2115 ost->source_index = -1;
2116 ost->filter = ofilter;
2119 ofilter->format = -1;
2121 if (ost->stream_copy) {
2122 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2123 "which is fed from a complex filtergraph. Filtering and streamcopy "
2124 "cannot be used together.\n", ost->file_index, ost->index);
2128 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2129 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2130 av_log(NULL, AV_LOG_ERROR,
2131 "%s '%s' was specified through the %s option "
2132 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2133 "%s and -filter_complex cannot be used together for the same stream.\n",
2134 ost->filters ? "Filtergraph" : "Filtergraph script",
2135 ost->filters ? ost->filters : ost->filters_script,
2136 opt, ost->file_index, ost->index, opt);
2140 avfilter_inout_free(&ofilter->out_tmp);
2143 static int init_complex_filters(void)
2147 for (i = 0; i < nb_filtergraphs; i++) {
2148 ret = init_complex_filtergraph(filtergraphs[i]);
2155 static int open_output_file(OptionsContext *o, const char *filename)
2157 AVFormatContext *oc;
2162 AVDictionary *unused_opts = NULL;
2163 AVDictionaryEntry *e = NULL;
2164 int format_flags = 0;
2166 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2167 o->stop_time = INT64_MAX;
2168 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2171 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2172 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2173 if (o->stop_time <= start_time) {
2174 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2177 o->recording_time = o->stop_time - start_time;
2181 GROW_ARRAY(output_files, nb_output_files);
2182 of = av_mallocz(sizeof(*of));
2185 output_files[nb_output_files - 1] = of;
2187 of->ost_index = nb_output_streams;
2188 of->recording_time = o->recording_time;
2189 of->start_time = o->start_time;
2190 of->limit_filesize = o->limit_filesize;
2191 of->shortest = o->shortest;
2192 av_dict_copy(&of->opts, o->g->format_opts, 0);
2194 if (!strcmp(filename, "-"))
2197 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2199 print_error(filename, err);
2204 if (o->recording_time != INT64_MAX)
2205 oc->duration = o->recording_time;
2207 oc->interrupt_callback = int_cb;
2209 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2211 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2212 av_opt_eval_flags(oc, o, e->value, &format_flags);
2215 format_flags |= AVFMT_FLAG_BITEXACT;
2216 oc->flags |= AVFMT_FLAG_BITEXACT;
2219 /* create streams for all unlabeled output pads */
2220 for (i = 0; i < nb_filtergraphs; i++) {
2221 FilterGraph *fg = filtergraphs[i];
2222 for (j = 0; j < fg->nb_outputs; j++) {
2223 OutputFilter *ofilter = fg->outputs[j];
2225 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2228 switch (ofilter->type) {
2229 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2230 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2231 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2233 init_output_filter(ofilter, o, oc);
2237 if (!o->nb_stream_maps) {
2238 char *subtitle_codec_name = NULL;
2239 /* pick the "best" stream of each type */
2241 /* video: highest resolution */
2242 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2243 int best_score = 0, idx = -1;
2244 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2245 for (i = 0; i < nb_input_streams; i++) {
2247 ist = input_streams[i];
2248 score = ist->st->codecpar->width * ist->st->codecpar->height
2249 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2250 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2251 if (ist->user_set_discard == AVDISCARD_ALL)
2253 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2255 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2256 score > best_score) {
2257 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2264 new_video_stream(o, oc, idx);
2267 /* audio: most channels */
2268 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2269 int best_score = 0, idx = -1;
2270 for (i = 0; i < nb_input_streams; i++) {
2272 ist = input_streams[i];
2273 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2274 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2275 if (ist->user_set_discard == AVDISCARD_ALL)
2277 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2278 score > best_score) {
2284 new_audio_stream(o, oc, idx);
2287 /* subtitles: pick first */
2288 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2289 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2290 for (i = 0; i < nb_input_streams; i++)
2291 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2292 AVCodecDescriptor const *input_descriptor =
2293 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2294 AVCodecDescriptor const *output_descriptor = NULL;
2295 AVCodec const *output_codec =
2296 avcodec_find_encoder(oc->oformat->subtitle_codec);
2297 int input_props = 0, output_props = 0;
2298 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2301 output_descriptor = avcodec_descriptor_get(output_codec->id);
2302 if (input_descriptor)
2303 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2304 if (output_descriptor)
2305 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2306 if (subtitle_codec_name ||
2307 input_props & output_props ||
2308 // Map dvb teletext which has neither property to any output subtitle encoder
2309 input_descriptor && output_descriptor &&
2310 (!input_descriptor->props ||
2311 !output_descriptor->props)) {
2312 new_subtitle_stream(o, oc, i);
2317 /* Data only if codec id match */
2318 if (!o->data_disable ) {
2319 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2320 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2321 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2323 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2324 && input_streams[i]->st->codecpar->codec_id == codec_id )
2325 new_data_stream(o, oc, i);
2329 for (i = 0; i < o->nb_stream_maps; i++) {
2330 StreamMap *map = &o->stream_maps[i];
2335 if (map->linklabel) {
2337 OutputFilter *ofilter = NULL;
2340 for (j = 0; j < nb_filtergraphs; j++) {
2341 fg = filtergraphs[j];
2342 for (k = 0; k < fg->nb_outputs; k++) {
2343 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2344 if (out && !strcmp(out->name, map->linklabel)) {
2345 ofilter = fg->outputs[k];
2352 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2353 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2356 init_output_filter(ofilter, o, oc);
2358 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2360 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2361 if (ist->user_set_discard == AVDISCARD_ALL) {
2362 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2363 map->file_index, map->stream_index);
2366 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2368 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2370 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2372 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2376 switch (ist->st->codecpar->codec_type) {
2377 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2378 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2379 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2380 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2381 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2382 case AVMEDIA_TYPE_UNKNOWN:
2383 if (copy_unknown_streams) {
2384 ost = new_unknown_stream (o, oc, src_idx);
2388 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2389 "Cannot map stream #%d:%d - unsupported type.\n",
2390 map->file_index, map->stream_index);
2391 if (!ignore_unknown_streams) {
2392 av_log(NULL, AV_LOG_FATAL,
2393 "If you want unsupported types ignored instead "
2394 "of failing, please use the -ignore_unknown option\n"
2395 "If you want them copied, please use -copy_unknown\n");
2400 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2401 + map->sync_stream_index];
2406 /* handle attached files */
2407 for (i = 0; i < o->nb_attachments; i++) {
2409 uint8_t *attachment;
2413 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2414 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2418 if ((len = avio_size(pb)) <= 0) {
2419 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2423 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2424 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2425 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2429 avio_read(pb, attachment, len);
2430 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2432 ost = new_attachment_stream(o, oc, -1);
2433 ost->stream_copy = 0;
2434 ost->attachment_filename = o->attachments[i];
2435 ost->st->codecpar->extradata = attachment;
2436 ost->st->codecpar->extradata_size = len;
2438 p = strrchr(o->attachments[i], '/');
2439 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2443 #if FF_API_LAVF_AVCTX
2444 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2445 AVDictionaryEntry *e;
2446 ost = output_streams[i];
2448 if ((ost->stream_copy || ost->attachment_filename)
2449 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2450 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2451 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2456 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2457 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2458 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2462 /* check if all codec options have been used */
2463 unused_opts = strip_specifiers(o->g->codec_opts);
2464 for (i = of->ost_index; i < nb_output_streams; i++) {
2466 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2467 AV_DICT_IGNORE_SUFFIX)))
2468 av_dict_set(&unused_opts, e->key, NULL, 0);
2472 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2473 const AVClass *class = avcodec_get_class();
2474 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2475 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2476 const AVClass *fclass = avformat_get_class();
2477 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2478 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2479 if (!option || foption)
2483 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2484 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2485 "output file #%d (%s) is not an encoding option.\n", e->key,
2486 option->help ? option->help : "", nb_output_files - 1,
2491 // gop_timecode is injected by generic code but not always used
2492 if (!strcmp(e->key, "gop_timecode"))
2495 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2496 "output file #%d (%s) has not been used for any stream. The most "
2497 "likely reason is either wrong type (e.g. a video option with "
2498 "no video streams) or that it is a private option of some encoder "
2499 "which was not actually used for any stream.\n", e->key,
2500 option->help ? option->help : "", nb_output_files - 1, filename);
2502 av_dict_free(&unused_opts);
2504 /* set the decoding_needed flags and create simple filtergraphs */
2505 for (i = of->ost_index; i < nb_output_streams; i++) {
2506 OutputStream *ost = output_streams[i];
2508 if (ost->encoding_needed && ost->source_index >= 0) {
2509 InputStream *ist = input_streams[ost->source_index];
2510 ist->decoding_needed |= DECODING_FOR_OST;
2512 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2513 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2514 err = init_simple_filtergraph(ist, ost);
2516 av_log(NULL, AV_LOG_ERROR,
2517 "Error initializing a simple filtergraph between streams "
2518 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2519 nb_output_files - 1, ost->st->index);
2525 /* set the filter output constraints */
2527 OutputFilter *f = ost->filter;
2529 switch (ost->enc_ctx->codec_type) {
2530 case AVMEDIA_TYPE_VIDEO:
2531 f->frame_rate = ost->frame_rate;
2532 f->width = ost->enc_ctx->width;
2533 f->height = ost->enc_ctx->height;
2534 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2535 f->format = ost->enc_ctx->pix_fmt;
2536 } else if (ost->enc->pix_fmts) {
2538 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2540 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2543 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2546 case AVMEDIA_TYPE_AUDIO:
2547 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2548 f->format = ost->enc_ctx->sample_fmt;
2549 } else if (ost->enc->sample_fmts) {
2551 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2553 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2556 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2558 if (ost->enc_ctx->sample_rate) {
2559 f->sample_rate = ost->enc_ctx->sample_rate;
2560 } else if (ost->enc->supported_samplerates) {
2562 while (ost->enc->supported_samplerates[count])
2564 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2565 if (!f->sample_rates)
2567 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2568 (count + 1) * sizeof(*f->sample_rates));
2570 if (ost->enc_ctx->channels) {
2571 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2572 } else if (ost->enc->channel_layouts) {
2574 while (ost->enc->channel_layouts[count])
2576 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2577 if (!f->channel_layouts)
2579 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2580 (count + 1) * sizeof(*f->channel_layouts));
2587 /* check filename in case of an image number is expected */
2588 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2589 if (!av_filename_number_test(oc->url)) {
2590 print_error(oc->url, AVERROR(EINVAL));
2595 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2596 av_log(NULL, AV_LOG_ERROR,
2597 "No input streams but output needs an input stream\n");
2601 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2602 /* test if it already exists to avoid losing precious files */
2603 assert_file_overwrite(filename);
2606 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2607 &oc->interrupt_callback,
2609 print_error(filename, err);
2612 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2613 assert_file_overwrite(filename);
2615 if (o->mux_preload) {
2616 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2618 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2621 for (i = 0; i < o->nb_metadata_map; i++) {
2623 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2625 if (in_file_index >= nb_input_files) {
2626 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2629 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2630 in_file_index >= 0 ?
2631 input_files[in_file_index]->ctx : NULL, o);
2635 if (o->chapters_input_file >= nb_input_files) {
2636 if (o->chapters_input_file == INT_MAX) {
2637 /* copy chapters from the first input file that has them*/
2638 o->chapters_input_file = -1;
2639 for (i = 0; i < nb_input_files; i++)
2640 if (input_files[i]->ctx->nb_chapters) {
2641 o->chapters_input_file = i;
2645 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2646 o->chapters_input_file);
2650 if (o->chapters_input_file >= 0)
2651 copy_chapters(input_files[o->chapters_input_file], of,
2652 !o->metadata_chapters_manual);
2654 /* copy global metadata by default */
2655 if (!o->metadata_global_manual && nb_input_files){
2656 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2657 AV_DICT_DONT_OVERWRITE);
2658 if(o->recording_time != INT64_MAX)
2659 av_dict_set(&oc->metadata, "duration", NULL, 0);
2660 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2661 av_dict_set(&oc->metadata, "company_name", NULL, 0);
2662 av_dict_set(&oc->metadata, "product_name", NULL, 0);
2663 av_dict_set(&oc->metadata, "product_version", NULL, 0);
2665 if (!o->metadata_streams_manual)
2666 for (i = of->ost_index; i < nb_output_streams; i++) {
2668 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2670 ist = input_streams[output_streams[i]->source_index];
2671 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2672 if (!output_streams[i]->stream_copy) {
2673 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2677 /* process manually set programs */
2678 for (i = 0; i < o->nb_program; i++) {
2679 const char *p = o->program[i].u.str;
2684 const char *p2 = av_get_token(&p, ":");
2685 const char *to_dealloc = p2;
2692 key = av_get_token(&p2, "=");
2694 av_freep(&to_dealloc);
2700 if (!strcmp(key, "program_num"))
2701 progid = strtol(p2, NULL, 0);
2702 av_freep(&to_dealloc);
2706 program = av_new_program(oc, progid);
2708 p = o->program[i].u.str;
2710 const char *p2 = av_get_token(&p, ":");
2711 const char *to_dealloc = p2;
2717 key = av_get_token(&p2, "=");
2719 av_log(NULL, AV_LOG_FATAL,
2720 "No '=' character in program string %s.\n",
2728 if (!strcmp(key, "title")) {
2729 av_dict_set(&program->metadata, "title", p2, 0);
2730 } else if (!strcmp(key, "program_num")) {
2731 } else if (!strcmp(key, "st")) {
2732 int st_num = strtol(p2, NULL, 0);
2733 av_program_add_stream_index(oc, progid, st_num);
2735 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2738 av_freep(&to_dealloc);
2743 /* process manually set metadata */
2744 for (i = 0; i < o->nb_metadata; i++) {
2747 const char *stream_spec;
2748 int index = 0, j, ret = 0;
2750 val = strchr(o->metadata[i].u.str, '=');
2752 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2753 o->metadata[i].u.str);
2758 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2760 for (j = 0; j < oc->nb_streams; j++) {
2761 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2762 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2763 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2765 double theta = av_strtod(val, &tail);
2767 ost->rotate_overridden = 1;
2768 ost->rotate_override_value = theta;
2771 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2783 if (index < 0 || index >= oc->nb_chapters) {
2784 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2787 m = &oc->chapters[index]->metadata;
2790 if (index < 0 || index >= oc->nb_programs) {
2791 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2794 m = &oc->programs[index]->metadata;
2797 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2800 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2807 static int opt_target(void *optctx, const char *opt, const char *arg)
2809 OptionsContext *o = optctx;
2810 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2811 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2813 if (!strncmp(arg, "pal-", 4)) {
2816 } else if (!strncmp(arg, "ntsc-", 5)) {
2819 } else if (!strncmp(arg, "film-", 5)) {
2823 /* Try to determine PAL/NTSC by peeking in the input files */
2824 if (nb_input_files) {
2826 for (j = 0; j < nb_input_files; j++) {
2827 for (i = 0; i < input_files[j]->nb_streams; i++) {
2828 AVStream *st = input_files[j]->ctx->streams[i];
2830 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2832 fr = st->time_base.den * 1000LL / st->time_base.num;
2836 } else if ((fr == 29970) || (fr == 23976)) {
2841 if (norm != UNKNOWN)
2845 if (norm != UNKNOWN)
2846 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2849 if (norm == UNKNOWN) {
2850 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2851 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2852 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2856 if (!strcmp(arg, "vcd")) {
2857 opt_video_codec(o, "c:v", "mpeg1video");
2858 opt_audio_codec(o, "c:a", "mp2");
2859 parse_option(o, "f", "vcd", options);
2861 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2862 parse_option(o, "r", frame_rates[norm], options);
2863 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2865 opt_default(NULL, "b:v", "1150000");
2866 opt_default(NULL, "maxrate:v", "1150000");
2867 opt_default(NULL, "minrate:v", "1150000");
2868 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2870 opt_default(NULL, "b:a", "224000");
2871 parse_option(o, "ar", "44100", options);
2872 parse_option(o, "ac", "2", options);
2874 opt_default(NULL, "packetsize", "2324");
2875 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2877 /* We have to offset the PTS, so that it is consistent with the SCR.
2878 SCR starts at 36000, but the first two packs contain only padding
2879 and the first pack from the other stream, respectively, may also have
2880 been written before.
2881 So the real data starts at SCR 36000+3*1200. */
2882 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2883 } else if (!strcmp(arg, "svcd")) {
2885 opt_video_codec(o, "c:v", "mpeg2video");
2886 opt_audio_codec(o, "c:a", "mp2");
2887 parse_option(o, "f", "svcd", options);
2889 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2890 parse_option(o, "r", frame_rates[norm], options);
2891 parse_option(o, "pix_fmt", "yuv420p", options);
2892 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2894 opt_default(NULL, "b:v", "2040000");
2895 opt_default(NULL, "maxrate:v", "2516000");
2896 opt_default(NULL, "minrate:v", "0"); // 1145000;
2897 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2898 opt_default(NULL, "scan_offset", "1");
2900 opt_default(NULL, "b:a", "224000");
2901 parse_option(o, "ar", "44100", options);
2903 opt_default(NULL, "packetsize", "2324");
2905 } else if (!strcmp(arg, "dvd")) {
2907 opt_video_codec(o, "c:v", "mpeg2video");
2908 opt_audio_codec(o, "c:a", "ac3");
2909 parse_option(o, "f", "dvd", options);
2911 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2912 parse_option(o, "r", frame_rates[norm], options);
2913 parse_option(o, "pix_fmt", "yuv420p", options);
2914 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2916 opt_default(NULL, "b:v", "6000000");
2917 opt_default(NULL, "maxrate:v", "9000000");
2918 opt_default(NULL, "minrate:v", "0"); // 1500000;
2919 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2921 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2922 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2924 opt_default(NULL, "b:a", "448000");
2925 parse_option(o, "ar", "48000", options);
2927 } else if (!strncmp(arg, "dv", 2)) {
2929 parse_option(o, "f", "dv", options);
2931 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2932 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2933 norm == PAL ? "yuv420p" : "yuv411p", options);
2934 parse_option(o, "r", frame_rates[norm], options);
2936 parse_option(o, "ar", "48000", options);
2937 parse_option(o, "ac", "2", options);
2940 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2941 return AVERROR(EINVAL);
2944 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2945 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2950 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2952 av_free (vstats_filename);
2953 vstats_filename = av_strdup (arg);
2957 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2960 time_t today2 = time(NULL);
2961 struct tm *today = localtime(&today2);
2963 if (!today) { // maybe tomorrow
2964 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2968 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2970 return opt_vstats_file(NULL, opt, filename);
2973 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2975 OptionsContext *o = optctx;
2976 return parse_option(o, "frames:v", arg, options);
2979 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2981 OptionsContext *o = optctx;
2982 return parse_option(o, "frames:a", arg, options);
2985 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2987 OptionsContext *o = optctx;
2988 return parse_option(o, "frames:d", arg, options);
2991 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2994 AVDictionary *cbak = codec_opts;
2995 AVDictionary *fbak = format_opts;
2999 ret = opt_default(NULL, opt, arg);
3001 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
3002 av_dict_copy(&o->g->format_opts, format_opts, 0);
3003 av_dict_free(&codec_opts);
3004 av_dict_free(&format_opts);
3011 static int opt_preset(void *optctx, const char *opt, const char *arg)
3013 OptionsContext *o = optctx;
3015 char filename[1000], line[1000], tmp_line[1000];
3016 const char *codec_name = NULL;
3020 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3022 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3023 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3024 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3026 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3030 while (fgets(line, sizeof(line), f)) {
3031 char *key = tmp_line, *value, *endptr;
3033 if (strcspn(line, "#\n\r") == 0)
3035 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3036 if (!av_strtok(key, "=", &value) ||
3037 !av_strtok(value, "\r\n", &endptr)) {
3038 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3041 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3043 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3044 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3045 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3046 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3047 else if (opt_default_new(o, key, value) < 0) {
3048 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3049 filename, line, key, value);
3059 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3061 OptionsContext *o = optctx;
3063 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3065 return AVERROR(ENOMEM);
3066 ret = parse_option(o, s, arg, options);
3071 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3073 OptionsContext *o = optctx;
3075 if(!strcmp(opt, "ab")){
3076 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3078 } else if(!strcmp(opt, "b")){
3079 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3080 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3083 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3087 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3089 OptionsContext *o = optctx;
3092 if(!strcmp(opt, "qscale")){
3093 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3094 return parse_option(o, "q:v", arg, options);
3096 s = av_asprintf("q%s", opt + 6);
3098 return AVERROR(ENOMEM);
3099 ret = parse_option(o, s, arg, options);
3104 static int opt_profile(void *optctx, const char *opt, const char *arg)
3106 OptionsContext *o = optctx;
3107 if(!strcmp(opt, "profile")){
3108 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3109 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3112 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3116 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3118 OptionsContext *o = optctx;
3119 return parse_option(o, "filter:v", arg, options);
3122 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3124 OptionsContext *o = optctx;
3125 return parse_option(o, "filter:a", arg, options);
3128 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3130 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3131 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3132 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3133 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3135 if (video_sync_method == VSYNC_AUTO)
3136 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3140 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3142 OptionsContext *o = optctx;
3144 char *tcr = av_asprintf("timecode=%s", arg);
3146 return AVERROR(ENOMEM);
3147 ret = parse_option(o, "metadata:g", tcr, options);
3149 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3154 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3156 OptionsContext *o = optctx;
3157 char layout_str[32];
3160 int ret, channels, ac_str_size;
3163 layout = av_get_channel_layout(arg);
3165 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3166 return AVERROR(EINVAL);
3168 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3169 ret = opt_default_new(o, opt, layout_str);
3173 /* set 'ac' option based on channel layout */
3174 channels = av_get_channel_layout_nb_channels(layout);
3175 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3176 stream_str = strchr(opt, ':');
3177 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3178 ac_str = av_mallocz(ac_str_size);
3180 return AVERROR(ENOMEM);
3181 av_strlcpy(ac_str, "ac", 3);
3183 av_strlcat(ac_str, stream_str, ac_str_size);
3184 ret = parse_option(o, ac_str, layout_str, options);
3190 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3192 OptionsContext *o = optctx;
3193 return parse_option(o, "q:a", arg, options);
3196 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3198 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3199 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3200 return AVERROR(ENOMEM);
3201 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3202 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3203 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3204 return AVERROR(ENOMEM);
3206 input_stream_potentially_available = 1;
3211 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3213 uint8_t *graph_desc = read_file(arg);
3215 return AVERROR(EINVAL);
3217 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3218 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3219 return AVERROR(ENOMEM);
3220 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3221 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3223 input_stream_potentially_available = 1;
3228 void show_help_default(const char *opt, const char *arg)
3230 /* per-file options have at least one of those set */
3231 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3232 int show_advanced = 0, show_avoptions = 0;
3235 if (!strcmp(opt, "long"))
3237 else if (!strcmp(opt, "full"))
3238 show_advanced = show_avoptions = 1;
3240 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3245 printf("Getting help:\n"
3246 " -h -- print basic options\n"
3247 " -h long -- print more options\n"
3248 " -h full -- print all options (including all format and codec specific options, very long)\n"
3249 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3250 " See man %s for detailed description of the options.\n"
3251 "\n", program_name);
3253 show_help_options(options, "Print help / information / capabilities:",
3256 show_help_options(options, "Global options (affect whole program "
3257 "instead of just one file):",
3258 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3260 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3261 per_file | OPT_EXIT, 0);
3263 show_help_options(options, "Per-file main options:", 0,
3264 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3265 OPT_EXIT, per_file);
3267 show_help_options(options, "Advanced per-file options:",
3268 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3270 show_help_options(options, "Video options:",
3271 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3273 show_help_options(options, "Advanced Video options:",
3274 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3276 show_help_options(options, "Audio options:",
3277 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3279 show_help_options(options, "Advanced Audio options:",
3280 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3281 show_help_options(options, "Subtitle options:",
3282 OPT_SUBTITLE, 0, 0);
3285 if (show_avoptions) {
3286 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3287 show_help_children(avcodec_get_class(), flags);
3288 show_help_children(avformat_get_class(), flags);
3290 show_help_children(sws_get_class(), flags);
3292 #if CONFIG_SWRESAMPLE
3293 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3295 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3296 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3300 void show_usage(void)
3302 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3303 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3304 av_log(NULL, AV_LOG_INFO, "\n");
3312 static const OptionGroupDef groups[] = {
3313 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3314 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3317 static int open_files(OptionGroupList *l, const char *inout,
3318 int (*open_file)(OptionsContext*, const char*))
3322 for (i = 0; i < l->nb_groups; i++) {
3323 OptionGroup *g = &l->groups[i];
3329 ret = parse_optgroup(&o, g);
3331 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3332 "%s.\n", inout, g->arg);
3337 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3338 ret = open_file(&o, g->arg);
3341 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3345 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3351 int ffmpeg_parse_options(int argc, char **argv)
3353 OptionParseContext octx;
3357 memset(&octx, 0, sizeof(octx));
3359 /* split the commandline into an internal representation */
3360 ret = split_commandline(&octx, argc, argv, options, groups,
3361 FF_ARRAY_ELEMS(groups));
3363 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3367 /* apply global options */
3368 ret = parse_optgroup(NULL, &octx.global_opts);
3370 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3374 /* configure terminal and setup signal handlers */
3377 /* open input files */
3378 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3380 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3384 /* create the complex filtergraphs */
3385 ret = init_complex_filters();
3387 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3391 /* open output files */
3392 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3394 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3398 check_filter_outputs();
3401 uninit_parse_context(&octx);
3403 av_strerror(ret, error, sizeof(error));
3404 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3409 static int opt_progress(void *optctx, const char *opt, const char *arg)
3411 AVIOContext *avio = NULL;
3414 if (!strcmp(arg, "-"))
3416 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3418 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3419 arg, av_err2str(ret));
3422 progress_avio = avio;
3426 #define OFFSET(x) offsetof(OptionsContext, x)
3427 const OptionDef options[] = {
3429 CMDUTILS_COMMON_OPTIONS
3430 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3431 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3432 "force format", "fmt" },
3433 { "y", OPT_BOOL, { &file_overwrite },
3434 "overwrite output files" },
3435 { "n", OPT_BOOL, { &no_file_overwrite },
3436 "never overwrite output files" },
3437 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3438 "Ignore unknown stream types" },
3439 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3440 "Copy unknown stream types" },
3441 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3442 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3443 "codec name", "codec" },
3444 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3445 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3446 "codec name", "codec" },
3447 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3448 OPT_OUTPUT, { .off = OFFSET(presets) },
3449 "preset name", "preset" },
3450 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3451 OPT_OUTPUT, { .func_arg = opt_map },
3452 "set input stream mapping",
3453 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3454 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3455 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3456 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3457 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3458 "set metadata information of outfile from infile",
3459 "outfile[,metadata]:infile[,metadata]" },
3460 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3461 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3462 "set chapters mapping", "input_file_index" },
3463 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3464 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3465 "record or transcode \"duration\" seconds of audio/video",
3467 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3468 "record or transcode stop time", "time_stop" },
3469 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3470 "set the limit file size in bytes", "limit_size" },
3471 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3472 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3473 "set the start time offset", "time_off" },
3474 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3475 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3476 "set the start time offset relative to EOF", "time_off" },
3477 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3478 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3479 "enable/disable seeking by timestamp with -ss" },
3480 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3481 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3482 "enable/disable accurate seeking with -ss" },
3483 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3484 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3485 "set the input ts offset", "time_off" },
3486 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3487 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3488 "set the input ts scale", "scale" },
3489 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3490 "set the recording timestamp ('now' to set the current time)", "time" },
3491 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3492 "add metadata", "string=string" },
3493 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3494 "add program with specified streams", "title=string:st=number..." },
3495 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3496 OPT_OUTPUT, { .func_arg = opt_data_frames },
3497 "set the number of data frames to output", "number" },
3498 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3499 "add timings for benchmarking" },
3500 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3501 "add timings for each task" },
3502 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3503 "write program-readable progress information", "url" },
3504 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3505 "enable or disable interaction on standard input" },
3506 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3507 "set max runtime in seconds in CPU user time", "limit" },
3508 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3509 "dump each input packet" },
3510 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3511 "when dumping packets, also dump the payload" },
3512 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3513 OPT_INPUT, { .off = OFFSET(rate_emu) },
3514 "read input at native frame rate", "" },
3515 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3516 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3517 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3518 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3519 "video sync method", "" },
3520 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3521 "frame drop threshold", "" },
3522 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3523 "audio sync method", "" },
3524 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3525 "audio drift threshold", "threshold" },
3526 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3527 "copy timestamps" },
3528 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3529 "shift input timestamps to start at 0 when using copyts" },
3530 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3531 "copy input stream time base when stream copying", "mode" },
3532 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3533 OPT_OUTPUT, { .off = OFFSET(shortest) },
3534 "finish encoding within shortest input" },
3535 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3536 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3538 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3539 OPT_OUTPUT, { .off = OFFSET(apad) },
3541 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3542 "timestamp discontinuity delta threshold", "threshold" },
3543 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3544 "timestamp error delta threshold", "threshold" },
3545 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3546 "exit on error", "error" },
3547 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3548 "abort on the specified condition flags", "flags" },
3549 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3550 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3551 "copy initial non-keyframes" },
3552 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3553 "copy or discard frames before start time" },
3554 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3555 "set the number of frames to output", "number" },
3556 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3557 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3558 "force codec tag/fourcc", "fourcc/tag" },
3559 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3560 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3561 "use fixed quality scale (VBR)", "q" },
3562 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3563 OPT_OUTPUT, { .func_arg = opt_qscale },
3564 "use fixed quality scale (VBR)", "q" },
3565 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3566 "set profile", "profile" },
3567 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3568 "set stream filtergraph", "filter_graph" },
3569 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3570 "number of non-complex filter threads" },
3571 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3572 "read stream filtergraph description from a file", "filename" },
3573 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3574 "reinit filtergraph on input parameter changes", "" },
3575 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3576 "create a complex filtergraph", "graph_description" },
3577 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3578 "number of threads for -filter_complex" },
3579 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3580 "create a complex filtergraph", "graph_description" },
3581 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3582 "read complex filtergraph description from a file", "filename" },
3583 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3584 "enable automatic conversion filters globally" },
3585 { "stats", OPT_BOOL, { &print_stats },
3586 "print progress report during encoding", },
3587 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
3588 "set the period at which ffmpeg updates stats and -progress output", "time" },
3589 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3590 OPT_OUTPUT, { .func_arg = opt_attach },
3591 "add an attachment to the output file", "filename" },
3592 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3593 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3594 "extract an attachment into a file", "filename" },
3595 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3596 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3597 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3598 "print timestamp debugging info" },
3599 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3600 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3601 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3602 OPT_INPUT, { .off = OFFSET(discard) },
3604 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3605 OPT_OUTPUT, { .off = OFFSET(disposition) },
3606 "disposition", "" },
3607 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3608 { .off = OFFSET(thread_queue_size) },
3609 "set the maximum number of queued packets from the demuxer" },
3610 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3611 "read and decode the streams to fill missing information with heuristics" },
3614 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3615 "set the number of video frames to output", "number" },
3616 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3617 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3618 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3619 { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3620 OPT_OUTPUT, { .off = OFFSET(max_frame_rates) },
3621 "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3622 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3623 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3624 "set frame size (WxH or abbreviation)", "size" },
3625 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3626 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3627 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3628 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3629 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3630 "set pixel format", "format" },
3631 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3632 "set the number of bits per raw sample", "number" },
3633 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3634 "deprecated use -g 1" },
3635 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3637 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3638 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3639 "rate control override for specific intervals", "override" },
3640 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3641 OPT_OUTPUT, { .func_arg = opt_video_codec },
3642 "force video codec ('copy' to copy stream)", "codec" },
3643 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3645 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3647 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3648 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3649 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3650 "select the pass number (1 to 3)", "n" },
3651 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3652 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3653 "select two pass log file name prefix", "prefix" },
3654 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3655 "this option is deprecated, use the yadif filter instead" },
3656 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3657 "calculate PSNR of compressed frames" },
3658 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3659 "dump video coding statistics to file" },
3660 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3661 "dump video coding statistics to file", "file" },
3662 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3663 "Version of the vstats format to use."},
3664 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3665 "set video filters", "filter_graph" },
3666 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3667 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3668 "specify intra matrix coeffs", "matrix" },
3669 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3670 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3671 "specify inter matrix coeffs", "matrix" },
3672 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3673 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3674 "specify intra matrix coeffs", "matrix" },
3675 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3676 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3677 "top=1/bottom=0/auto=-1 field first", "" },
3678 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3679 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3680 "force video tag/fourcc", "fourcc/tag" },
3681 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3682 "show QP histogram" },
3683 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3684 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3685 "force the selected framerate, disable the best supported framerate selection" },
3686 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3687 OPT_OUTPUT, { .func_arg = opt_streamid },
3688 "set the value of an outfile streamid", "streamIndex:value" },
3689 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3690 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3691 "force key frames at specified timestamps", "timestamps" },
3692 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3693 "audio bitrate (please use -b:a)", "bitrate" },
3694 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3695 "video bitrate (please use -b:v)", "bitrate" },
3696 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3697 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3698 "use HW accelerated decoding", "hwaccel name" },
3699 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3700 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3701 "select a device for HW acceleration", "devicename" },
3702 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3703 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3704 "select output format used with HW accelerated decoding", "format" },
3705 #if CONFIG_VIDEOTOOLBOX
3706 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3708 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3709 "show available HW acceleration methods" },
3710 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3711 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3712 "automatically insert correct rotate filters" },
3713 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3714 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3715 "automatically insert a scale filter at the end of the filter graph" },
3718 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3719 "set the number of audio frames to output", "number" },
3720 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3721 "set audio quality (codec-specific)", "quality", },
3722 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3723 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3724 "set audio sampling rate (in Hz)", "rate" },
3725 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3726 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3727 "set number of audio channels", "channels" },
3728 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3730 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3731 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3732 "force audio codec ('copy' to copy stream)", "codec" },
3733 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3734 OPT_OUTPUT, { .func_arg = opt_old2new },
3735 "force audio tag/fourcc", "fourcc/tag" },
3736 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3737 "change audio volume (256=normal)" , "volume" },
3738 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3739 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3740 "set sample format", "format" },
3741 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3742 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3743 "set channel layout", "layout" },
3744 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3745 "set audio filters", "filter_graph" },
3746 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3747 "set the maximum number of channels to try to guess the channel layout" },
3749 /* subtitle options */
3750 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3751 "disable subtitle" },
3752 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3753 "force subtitle codec ('copy' to copy stream)", "codec" },
3754 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3755 , "force subtitle tag/fourcc", "fourcc/tag" },
3756 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3757 "fix subtitles duration" },
3758 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3759 "set canvas size (WxH or abbreviation)", "size" },
3762 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3763 "deprecated, use -channel", "channel" },
3764 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3765 "deprecated, use -standard", "standard" },
3766 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3769 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3770 "set the maximum demux-decode delay", "seconds" },
3771 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3772 "set the initial demux-decode delay", "seconds" },
3773 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3774 "specify a file in which to print sdp information", "file" },
3776 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3777 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3778 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3779 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3780 "two special values are defined - "
3781 "0 = use frame rate (video) or sample rate (audio),"
3782 "-1 = match source time base", "ratio" },
3784 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3785 "A comma-separated list of bitstream filters", "bitstream_filters" },
3786 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3787 "deprecated", "audio bitstream_filters" },
3788 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3789 "deprecated", "video bitstream_filters" },
3791 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3792 "set the audio options to the indicated preset", "preset" },
3793 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3794 "set the video options to the indicated preset", "preset" },
3795 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3796 "set the subtitle options to the indicated preset", "preset" },
3797 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3798 "set options from indicated preset file", "filename" },
3800 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3801 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3802 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3803 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3805 /* data codec support */
3806 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3807 "force data codec ('copy' to copy stream)", "codec" },
3808 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3812 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3813 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3817 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3818 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3821 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3822 "initialise hardware device", "args" },
3823 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3824 "set hardware device used when filtering", "device" },