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 const 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 const AVClass *priv_class;
1121 /* because we set audio_channels based on both the "ac" and
1122 * "channel_layout" options, we need to check that the specified
1123 * demuxer actually has the "channels" option before setting it */
1124 if (file_iformat && (priv_class = file_iformat->priv_class) &&
1125 av_opt_find(&priv_class, "channels", NULL, 0,
1126 AV_OPT_SEARCH_FAKE_OBJ)) {
1127 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1130 if (o->nb_frame_rates) {
1131 const AVClass *priv_class;
1132 /* set the format-level framerate option;
1133 * this is important for video grabbers, e.g. x11 */
1134 if (file_iformat && (priv_class = file_iformat->priv_class) &&
1135 av_opt_find(&priv_class, "framerate", NULL, 0,
1136 AV_OPT_SEARCH_FAKE_OBJ)) {
1137 av_dict_set(&o->g->format_opts, "framerate",
1138 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1141 if (o->nb_frame_sizes) {
1142 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1144 if (o->nb_frame_pix_fmts)
1145 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1147 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1148 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1149 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1150 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1152 if (video_codec_name)
1153 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1154 if (audio_codec_name)
1155 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1156 if (subtitle_codec_name)
1157 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1158 if (data_codec_name)
1159 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1161 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1162 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1163 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1164 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1166 ic->flags |= AVFMT_FLAG_NONBLOCK;
1168 ic->flags |= AVFMT_FLAG_BITEXACT;
1169 ic->interrupt_callback = int_cb;
1171 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1172 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1173 scan_all_pmts_set = 1;
1175 /* open the input file with generic avformat function */
1176 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1178 print_error(filename, err);
1179 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1180 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1183 if (scan_all_pmts_set)
1184 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1185 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1186 assert_avoptions(o->g->format_opts);
1188 /* apply forced codec ids */
1189 for (i = 0; i < ic->nb_streams; i++)
1190 choose_decoder(o, ic, ic->streams[i]);
1192 if (find_stream_info) {
1193 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1194 int orig_nb_streams = ic->nb_streams;
1196 /* If not enough info to get the stream parameters, we decode the
1197 first frames to get it. (used in mpeg case for example) */
1198 ret = avformat_find_stream_info(ic, opts);
1200 for (i = 0; i < orig_nb_streams; i++)
1201 av_dict_free(&opts[i]);
1205 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1206 if (ic->nb_streams == 0) {
1207 avformat_close_input(&ic);
1213 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1214 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1215 o->start_time_eof = AV_NOPTS_VALUE;
1218 if (o->start_time_eof != AV_NOPTS_VALUE) {
1219 if (o->start_time_eof >= 0) {
1220 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1223 if (ic->duration > 0) {
1224 o->start_time = o->start_time_eof + ic->duration;
1225 if (o->start_time < 0) {
1226 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1227 o->start_time = AV_NOPTS_VALUE;
1230 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1232 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1233 /* add the stream start time */
1234 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1235 timestamp += ic->start_time;
1237 /* if seeking requested, we execute it */
1238 if (o->start_time != AV_NOPTS_VALUE) {
1239 int64_t seek_timestamp = timestamp;
1241 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1242 int dts_heuristic = 0;
1243 for (i=0; i<ic->nb_streams; i++) {
1244 const AVCodecParameters *par = ic->streams[i]->codecpar;
1245 if (par->video_delay) {
1250 if (dts_heuristic) {
1251 seek_timestamp -= 3*AV_TIME_BASE / 23;
1254 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1256 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1257 filename, (double)timestamp / AV_TIME_BASE);
1261 /* update the current parameters so that they match the one of the input stream */
1262 add_input_streams(o, ic);
1264 /* dump the file content */
1265 av_dump_format(ic, nb_input_files, filename, 0);
1267 GROW_ARRAY(input_files, nb_input_files);
1268 f = av_mallocz(sizeof(*f));
1271 input_files[nb_input_files - 1] = f;
1274 f->ist_index = nb_input_streams - ic->nb_streams;
1275 f->start_time = o->start_time;
1276 f->recording_time = o->recording_time;
1277 f->input_ts_offset = o->input_ts_offset;
1278 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1279 f->nb_streams = ic->nb_streams;
1280 f->rate_emu = o->rate_emu;
1281 f->accurate_seek = o->accurate_seek;
1284 f->time_base = (AVRational){ 1, 1 };
1285 f->pkt = av_packet_alloc();
1289 f->thread_queue_size = o->thread_queue_size;
1292 /* check if all codec options have been used */
1293 unused_opts = strip_specifiers(o->g->codec_opts);
1294 for (i = f->ist_index; i < nb_input_streams; i++) {
1296 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1297 AV_DICT_IGNORE_SUFFIX)))
1298 av_dict_set(&unused_opts, e->key, NULL, 0);
1302 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1303 const AVClass *class = avcodec_get_class();
1304 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1305 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1306 const AVClass *fclass = avformat_get_class();
1307 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1308 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1309 if (!option || foption)
1313 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1314 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1315 "input file #%d (%s) is not a decoding option.\n", e->key,
1316 option->help ? option->help : "", nb_input_files - 1,
1321 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1322 "input file #%d (%s) has not been used for any stream. The most "
1323 "likely reason is either wrong type (e.g. a video option with "
1324 "no video streams) or that it is a private option of some decoder "
1325 "which was not actually used for any stream.\n", e->key,
1326 option->help ? option->help : "", nb_input_files - 1, filename);
1328 av_dict_free(&unused_opts);
1330 for (i = 0; i < o->nb_dump_attachment; i++) {
1333 for (j = 0; j < ic->nb_streams; j++) {
1334 AVStream *st = ic->streams[j];
1336 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1337 dump_attachment(st, o->dump_attachment[i].u.str);
1341 input_stream_potentially_available = 1;
1346 static uint8_t *get_line(AVIOContext *s)
1352 if (avio_open_dyn_buf(&line) < 0) {
1353 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1357 while ((c = avio_r8(s)) && c != '\n')
1360 avio_close_dyn_buf(line, &buf);
1365 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1368 char filename[1000];
1369 const char *base[3] = { getenv("AVCONV_DATADIR"),
1374 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1378 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1379 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1380 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1383 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1384 i != 1 ? "" : "/.avconv", preset_name);
1385 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1391 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1393 enum AVMediaType type = ost->st->codecpar->codec_type;
1394 char *codec_name = NULL;
1396 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1397 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1399 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1400 NULL, ost->st->codecpar->codec_type);
1401 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1403 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1404 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1405 "probably disabled. Please choose an encoder manually.\n",
1406 ost->file_index, ost->index, s->oformat->name,
1407 avcodec_get_name(ost->st->codecpar->codec_id));
1408 return AVERROR_ENCODER_NOT_FOUND;
1410 } else if (!strcmp(codec_name, "copy"))
1411 ost->stream_copy = 1;
1413 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1414 ost->st->codecpar->codec_id = ost->enc->id;
1416 ost->encoding_needed = !ost->stream_copy;
1418 /* no encoding supported for other media types */
1419 ost->stream_copy = 1;
1420 ost->encoding_needed = 0;
1426 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1429 AVStream *st = avformat_new_stream(oc, NULL);
1430 int idx = oc->nb_streams - 1, ret = 0;
1431 const char *bsfs = NULL, *time_base = NULL;
1432 char *next, *codec_tag = NULL;
1437 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1441 if (oc->nb_streams - 1 < o->nb_streamid_map)
1442 st->id = o->streamid_map[oc->nb_streams - 1];
1444 GROW_ARRAY(output_streams, nb_output_streams);
1445 if (!(ost = av_mallocz(sizeof(*ost))))
1447 output_streams[nb_output_streams - 1] = ost;
1449 ost->file_index = nb_output_files - 1;
1452 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1453 st->codecpar->codec_type = type;
1455 ret = choose_encoder(o, oc, ost);
1457 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1458 "%d:%d\n", ost->file_index, ost->index);
1462 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1463 if (!ost->enc_ctx) {
1464 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1467 ost->enc_ctx->codec_type = type;
1469 ost->ref_par = avcodec_parameters_alloc();
1470 if (!ost->ref_par) {
1471 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1476 AVIOContext *s = NULL;
1477 char *buf = NULL, *arg = NULL, *preset = NULL;
1479 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1481 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1483 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1484 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1487 if (!buf[0] || buf[0] == '#') {
1491 if (!(arg = strchr(buf, '='))) {
1492 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1496 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1498 } while (!s->eof_reached);
1502 av_log(NULL, AV_LOG_FATAL,
1503 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1504 preset, ost->file_index, ost->index);
1508 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1513 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1515 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1518 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1519 q.num <= 0 || q.den <= 0) {
1520 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1526 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1529 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1531 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1534 ost->enc_timebase = q;
1537 ost->max_frames = INT64_MAX;
1538 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1539 for (i = 0; i<o->nb_max_frames; i++) {
1540 char *p = o->max_frames[i].specifier;
1541 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1542 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1547 ost->copy_prior_start = -1;
1548 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1550 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1551 if (bsfs && *bsfs) {
1552 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1554 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1559 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1561 uint32_t tag = strtol(codec_tag, &next, 0);
1563 tag = AV_RL32(codec_tag);
1564 ost->st->codecpar->codec_tag =
1565 ost->enc_ctx->codec_tag = tag;
1568 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1570 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1571 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1574 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1575 ost->disposition = av_strdup(ost->disposition);
1577 ost->max_muxing_queue_size = 128;
1578 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1579 ost->max_muxing_queue_size *= sizeof(ost->pkt);
1581 ost->muxing_queue_data_size = 0;
1583 ost->muxing_queue_data_threshold = 50*1024*1024;
1584 MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1586 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1587 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1589 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1591 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1592 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1593 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1595 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1597 ost->source_index = source_index;
1598 if (source_index >= 0) {
1599 ost->sync_ist = input_streams[source_index];
1600 input_streams[source_index]->discard = 0;
1601 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1603 ost->last_mux_dts = AV_NOPTS_VALUE;
1605 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1606 if (!ost->muxing_queue)
1612 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1615 const char *p = str;
1622 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1629 /* read file contents into a string */
1630 static uint8_t *read_file(const char *filename)
1632 AVIOContext *pb = NULL;
1633 AVIOContext *dyn_buf = NULL;
1634 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1635 uint8_t buf[1024], *str;
1638 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1642 ret = avio_open_dyn_buf(&dyn_buf);
1647 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1648 avio_write(dyn_buf, buf, ret);
1649 avio_w8(dyn_buf, 0);
1652 ret = avio_close_dyn_buf(dyn_buf, &str);
1658 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1661 AVStream *st = ost->st;
1663 if (ost->filters_script && ost->filters) {
1664 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1665 "output stream #%d:%d.\n", nb_output_files, st->index);
1669 if (ost->filters_script)
1670 return read_file(ost->filters_script);
1671 else if (ost->filters)
1672 return av_strdup(ost->filters);
1674 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1678 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1679 const OutputStream *ost, enum AVMediaType type)
1681 if (ost->filters_script || ost->filters) {
1682 av_log(NULL, AV_LOG_ERROR,
1683 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1684 "Filtering and streamcopy cannot be used together.\n",
1685 ost->filters ? "Filtergraph" : "Filtergraph script",
1686 ost->filters ? ost->filters : ost->filters_script,
1687 av_get_media_type_string(type), ost->file_index, ost->index);
1692 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1696 AVCodecContext *video_enc;
1697 char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
1699 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1701 video_enc = ost->enc_ctx;
1703 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1704 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1705 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1709 MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1710 if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1711 av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1715 if (frame_rate && max_frame_rate) {
1716 av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1720 if ((frame_rate || max_frame_rate) &&
1721 video_sync_method == VSYNC_PASSTHROUGH)
1722 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1724 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1725 if (frame_aspect_ratio) {
1727 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1728 q.num <= 0 || q.den <= 0) {
1729 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1732 ost->frame_aspect_ratio = q;
1735 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1736 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1738 if (!ost->stream_copy) {
1739 const char *p = NULL;
1740 char *frame_size = NULL;
1741 char *frame_pix_fmt = NULL;
1742 char *intra_matrix = NULL, *inter_matrix = NULL;
1743 char *chroma_intra_matrix = NULL;
1747 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1748 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1749 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1753 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1754 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1755 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1756 ost->keep_pix_fmt = 1;
1757 if (!*++frame_pix_fmt)
1758 frame_pix_fmt = NULL;
1760 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1761 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1764 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1767 video_enc->gop_size = 0;
1768 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1770 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1771 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1774 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1776 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1777 if (chroma_intra_matrix) {
1778 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1780 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1783 video_enc->chroma_intra_matrix = p;
1784 parse_matrix_coeffs(p, chroma_intra_matrix);
1786 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1788 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1789 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1792 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1795 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1796 for (i = 0; p; i++) {
1798 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1800 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1803 video_enc->rc_override =
1804 av_realloc_array(video_enc->rc_override,
1805 i + 1, sizeof(RcOverride));
1806 if (!video_enc->rc_override) {
1807 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1810 video_enc->rc_override[i].start_frame = start;
1811 video_enc->rc_override[i].end_frame = end;
1813 video_enc->rc_override[i].qscale = q;
1814 video_enc->rc_override[i].quality_factor = 1.0;
1817 video_enc->rc_override[i].qscale = 0;
1818 video_enc->rc_override[i].quality_factor = -q/100.0;
1823 video_enc->rc_override_count = i;
1826 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1829 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1832 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1833 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1836 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1837 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1841 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1842 if (ost->logfile_prefix &&
1843 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1847 char logfilename[1024];
1850 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1851 ost->logfile_prefix ? ost->logfile_prefix :
1852 DEFAULT_PASS_LOGFILENAME_PREFIX,
1854 if (!strcmp(ost->enc->name, "libx264")) {
1855 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1857 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1858 char *logbuffer = read_file(logfilename);
1861 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1865 video_enc->stats_in = logbuffer;
1867 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1868 f = av_fopen_utf8(logfilename, "wb");
1870 av_log(NULL, AV_LOG_FATAL,
1871 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1872 logfilename, strerror(errno));
1880 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1881 if (ost->forced_keyframes)
1882 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1884 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1886 ost->top_field_first = -1;
1887 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1890 ost->avfilter = get_ost_filters(o, oc, ost);
1894 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1897 if (ost->stream_copy)
1898 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1903 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1908 AVCodecContext *audio_enc;
1910 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1913 audio_enc = ost->enc_ctx;
1914 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1916 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1917 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1919 if (!ost->stream_copy) {
1920 char *sample_fmt = NULL;
1922 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1924 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1926 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1927 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1931 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1933 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1934 ost->apad = av_strdup(ost->apad);
1936 ost->avfilter = get_ost_filters(o, oc, ost);
1940 /* check for channel mapping for this audio stream */
1941 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1942 AudioChannelMap *map = &o->audio_channel_maps[n];
1943 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1944 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1947 if (map->channel_idx == -1) {
1949 } else if (ost->source_index < 0) {
1950 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1951 ost->file_index, ost->st->index);
1954 ist = input_streams[ost->source_index];
1957 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1958 if (av_reallocp_array(&ost->audio_channels_map,
1959 ost->audio_channels_mapped + 1,
1960 sizeof(*ost->audio_channels_map)
1964 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1970 if (ost->stream_copy)
1971 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1976 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1980 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1981 if (!ost->stream_copy) {
1982 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1989 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1993 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1994 if (!ost->stream_copy) {
1995 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
2002 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2004 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2005 ost->stream_copy = 1;
2010 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2014 AVCodecContext *subtitle_enc;
2016 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2018 subtitle_enc = ost->enc_ctx;
2020 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2022 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2024 if (!ost->stream_copy) {
2025 char *frame_size = NULL;
2027 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2028 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2029 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2037 /* arg format is "output-stream-index:streamid-value". */
2038 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2040 OptionsContext *o = optctx;
2045 av_strlcpy(idx_str, arg, sizeof(idx_str));
2046 p = strchr(idx_str, ':');
2048 av_log(NULL, AV_LOG_FATAL,
2049 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2054 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2055 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2056 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2060 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2062 AVFormatContext *is = ifile->ctx;
2063 AVFormatContext *os = ofile->ctx;
2067 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2069 return AVERROR(ENOMEM);
2072 for (i = 0; i < is->nb_chapters; i++) {
2073 AVChapter *in_ch = is->chapters[i], *out_ch;
2074 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2075 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2076 AV_TIME_BASE_Q, in_ch->time_base);
2077 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2078 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2081 if (in_ch->end < ts_off)
2083 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2086 out_ch = av_mallocz(sizeof(AVChapter));
2088 return AVERROR(ENOMEM);
2090 out_ch->id = in_ch->id;
2091 out_ch->time_base = in_ch->time_base;
2092 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2093 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2096 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2098 os->chapters[os->nb_chapters++] = out_ch;
2103 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2104 AVFormatContext *oc)
2108 switch (ofilter->type) {
2109 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2110 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2112 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2117 ost->source_index = -1;
2118 ost->filter = ofilter;
2121 ofilter->format = -1;
2123 if (ost->stream_copy) {
2124 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2125 "which is fed from a complex filtergraph. Filtering and streamcopy "
2126 "cannot be used together.\n", ost->file_index, ost->index);
2130 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2131 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2132 av_log(NULL, AV_LOG_ERROR,
2133 "%s '%s' was specified through the %s option "
2134 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2135 "%s and -filter_complex cannot be used together for the same stream.\n",
2136 ost->filters ? "Filtergraph" : "Filtergraph script",
2137 ost->filters ? ost->filters : ost->filters_script,
2138 opt, ost->file_index, ost->index, opt);
2142 avfilter_inout_free(&ofilter->out_tmp);
2145 static int init_complex_filters(void)
2149 for (i = 0; i < nb_filtergraphs; i++) {
2150 ret = init_complex_filtergraph(filtergraphs[i]);
2157 static int open_output_file(OptionsContext *o, const char *filename)
2159 AVFormatContext *oc;
2164 AVDictionary *unused_opts = NULL;
2165 AVDictionaryEntry *e = NULL;
2166 int format_flags = 0;
2168 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2169 o->stop_time = INT64_MAX;
2170 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2173 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2174 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2175 if (o->stop_time <= start_time) {
2176 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2179 o->recording_time = o->stop_time - start_time;
2183 GROW_ARRAY(output_files, nb_output_files);
2184 of = av_mallocz(sizeof(*of));
2187 output_files[nb_output_files - 1] = of;
2189 of->ost_index = nb_output_streams;
2190 of->recording_time = o->recording_time;
2191 of->start_time = o->start_time;
2192 of->limit_filesize = o->limit_filesize;
2193 of->shortest = o->shortest;
2194 av_dict_copy(&of->opts, o->g->format_opts, 0);
2196 if (!strcmp(filename, "-"))
2199 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2201 print_error(filename, err);
2206 if (o->recording_time != INT64_MAX)
2207 oc->duration = o->recording_time;
2209 oc->interrupt_callback = int_cb;
2211 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2213 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2214 av_opt_eval_flags(oc, o, e->value, &format_flags);
2217 format_flags |= AVFMT_FLAG_BITEXACT;
2218 oc->flags |= AVFMT_FLAG_BITEXACT;
2221 /* create streams for all unlabeled output pads */
2222 for (i = 0; i < nb_filtergraphs; i++) {
2223 FilterGraph *fg = filtergraphs[i];
2224 for (j = 0; j < fg->nb_outputs; j++) {
2225 OutputFilter *ofilter = fg->outputs[j];
2227 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2230 switch (ofilter->type) {
2231 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2232 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2233 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2235 init_output_filter(ofilter, o, oc);
2239 if (!o->nb_stream_maps) {
2240 char *subtitle_codec_name = NULL;
2241 /* pick the "best" stream of each type */
2243 /* video: highest resolution */
2244 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2245 int best_score = 0, idx = -1;
2246 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2247 for (i = 0; i < nb_input_streams; i++) {
2249 ist = input_streams[i];
2250 score = ist->st->codecpar->width * ist->st->codecpar->height
2251 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2252 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2253 if (ist->user_set_discard == AVDISCARD_ALL)
2255 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2257 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2258 score > best_score) {
2259 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2266 new_video_stream(o, oc, idx);
2269 /* audio: most channels */
2270 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2271 int best_score = 0, idx = -1;
2272 for (i = 0; i < nb_input_streams; i++) {
2274 ist = input_streams[i];
2275 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2276 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2277 if (ist->user_set_discard == AVDISCARD_ALL)
2279 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2280 score > best_score) {
2286 new_audio_stream(o, oc, idx);
2289 /* subtitles: pick first */
2290 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2291 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2292 for (i = 0; i < nb_input_streams; i++)
2293 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2294 AVCodecDescriptor const *input_descriptor =
2295 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2296 AVCodecDescriptor const *output_descriptor = NULL;
2297 AVCodec const *output_codec =
2298 avcodec_find_encoder(oc->oformat->subtitle_codec);
2299 int input_props = 0, output_props = 0;
2300 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2303 output_descriptor = avcodec_descriptor_get(output_codec->id);
2304 if (input_descriptor)
2305 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2306 if (output_descriptor)
2307 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2308 if (subtitle_codec_name ||
2309 input_props & output_props ||
2310 // Map dvb teletext which has neither property to any output subtitle encoder
2311 input_descriptor && output_descriptor &&
2312 (!input_descriptor->props ||
2313 !output_descriptor->props)) {
2314 new_subtitle_stream(o, oc, i);
2319 /* Data only if codec id match */
2320 if (!o->data_disable ) {
2321 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2322 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2323 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2325 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2326 && input_streams[i]->st->codecpar->codec_id == codec_id )
2327 new_data_stream(o, oc, i);
2331 for (i = 0; i < o->nb_stream_maps; i++) {
2332 StreamMap *map = &o->stream_maps[i];
2337 if (map->linklabel) {
2339 OutputFilter *ofilter = NULL;
2342 for (j = 0; j < nb_filtergraphs; j++) {
2343 fg = filtergraphs[j];
2344 for (k = 0; k < fg->nb_outputs; k++) {
2345 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2346 if (out && !strcmp(out->name, map->linklabel)) {
2347 ofilter = fg->outputs[k];
2354 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2355 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2358 init_output_filter(ofilter, o, oc);
2360 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2362 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2363 if (ist->user_set_discard == AVDISCARD_ALL) {
2364 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2365 map->file_index, map->stream_index);
2368 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2370 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2372 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2374 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2378 switch (ist->st->codecpar->codec_type) {
2379 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2380 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2381 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2382 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2383 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2384 case AVMEDIA_TYPE_UNKNOWN:
2385 if (copy_unknown_streams) {
2386 ost = new_unknown_stream (o, oc, src_idx);
2390 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2391 "Cannot map stream #%d:%d - unsupported type.\n",
2392 map->file_index, map->stream_index);
2393 if (!ignore_unknown_streams) {
2394 av_log(NULL, AV_LOG_FATAL,
2395 "If you want unsupported types ignored instead "
2396 "of failing, please use the -ignore_unknown option\n"
2397 "If you want them copied, please use -copy_unknown\n");
2402 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2403 + map->sync_stream_index];
2408 /* handle attached files */
2409 for (i = 0; i < o->nb_attachments; i++) {
2411 uint8_t *attachment;
2415 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2416 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2420 if ((len = avio_size(pb)) <= 0) {
2421 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2425 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2426 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2427 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2431 avio_read(pb, attachment, len);
2432 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2434 ost = new_attachment_stream(o, oc, -1);
2435 ost->stream_copy = 0;
2436 ost->attachment_filename = o->attachments[i];
2437 ost->st->codecpar->extradata = attachment;
2438 ost->st->codecpar->extradata_size = len;
2440 p = strrchr(o->attachments[i], '/');
2441 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2445 #if FF_API_LAVF_AVCTX
2446 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2447 AVDictionaryEntry *e;
2448 ost = output_streams[i];
2450 if ((ost->stream_copy || ost->attachment_filename)
2451 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2452 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2453 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2458 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2459 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2460 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2464 /* check if all codec options have been used */
2465 unused_opts = strip_specifiers(o->g->codec_opts);
2466 for (i = of->ost_index; i < nb_output_streams; i++) {
2468 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2469 AV_DICT_IGNORE_SUFFIX)))
2470 av_dict_set(&unused_opts, e->key, NULL, 0);
2474 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2475 const AVClass *class = avcodec_get_class();
2476 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2477 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2478 const AVClass *fclass = avformat_get_class();
2479 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2480 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2481 if (!option || foption)
2485 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2486 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2487 "output file #%d (%s) is not an encoding option.\n", e->key,
2488 option->help ? option->help : "", nb_output_files - 1,
2493 // gop_timecode is injected by generic code but not always used
2494 if (!strcmp(e->key, "gop_timecode"))
2497 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2498 "output file #%d (%s) has not been used for any stream. The most "
2499 "likely reason is either wrong type (e.g. a video option with "
2500 "no video streams) or that it is a private option of some encoder "
2501 "which was not actually used for any stream.\n", e->key,
2502 option->help ? option->help : "", nb_output_files - 1, filename);
2504 av_dict_free(&unused_opts);
2506 /* set the decoding_needed flags and create simple filtergraphs */
2507 for (i = of->ost_index; i < nb_output_streams; i++) {
2508 OutputStream *ost = output_streams[i];
2510 if (ost->encoding_needed && ost->source_index >= 0) {
2511 InputStream *ist = input_streams[ost->source_index];
2512 ist->decoding_needed |= DECODING_FOR_OST;
2514 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2515 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2516 err = init_simple_filtergraph(ist, ost);
2518 av_log(NULL, AV_LOG_ERROR,
2519 "Error initializing a simple filtergraph between streams "
2520 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2521 nb_output_files - 1, ost->st->index);
2527 /* set the filter output constraints */
2529 OutputFilter *f = ost->filter;
2531 switch (ost->enc_ctx->codec_type) {
2532 case AVMEDIA_TYPE_VIDEO:
2533 f->frame_rate = ost->frame_rate;
2534 f->width = ost->enc_ctx->width;
2535 f->height = ost->enc_ctx->height;
2536 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2537 f->format = ost->enc_ctx->pix_fmt;
2538 } else if (ost->enc->pix_fmts) {
2540 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2542 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2545 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2548 case AVMEDIA_TYPE_AUDIO:
2549 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2550 f->format = ost->enc_ctx->sample_fmt;
2551 } else if (ost->enc->sample_fmts) {
2553 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2555 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2558 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2560 if (ost->enc_ctx->sample_rate) {
2561 f->sample_rate = ost->enc_ctx->sample_rate;
2562 } else if (ost->enc->supported_samplerates) {
2564 while (ost->enc->supported_samplerates[count])
2566 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2567 if (!f->sample_rates)
2569 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2570 (count + 1) * sizeof(*f->sample_rates));
2572 if (ost->enc_ctx->channels) {
2573 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2574 } else if (ost->enc->channel_layouts) {
2576 while (ost->enc->channel_layouts[count])
2578 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2579 if (!f->channel_layouts)
2581 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2582 (count + 1) * sizeof(*f->channel_layouts));
2589 /* check filename in case of an image number is expected */
2590 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2591 if (!av_filename_number_test(oc->url)) {
2592 print_error(oc->url, AVERROR(EINVAL));
2597 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2598 av_log(NULL, AV_LOG_ERROR,
2599 "No input streams but output needs an input stream\n");
2603 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2604 /* test if it already exists to avoid losing precious files */
2605 assert_file_overwrite(filename);
2608 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2609 &oc->interrupt_callback,
2611 print_error(filename, err);
2614 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2615 assert_file_overwrite(filename);
2617 if (o->mux_preload) {
2618 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2620 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2623 for (i = 0; i < o->nb_metadata_map; i++) {
2625 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2627 if (in_file_index >= nb_input_files) {
2628 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2631 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2632 in_file_index >= 0 ?
2633 input_files[in_file_index]->ctx : NULL, o);
2637 if (o->chapters_input_file >= nb_input_files) {
2638 if (o->chapters_input_file == INT_MAX) {
2639 /* copy chapters from the first input file that has them*/
2640 o->chapters_input_file = -1;
2641 for (i = 0; i < nb_input_files; i++)
2642 if (input_files[i]->ctx->nb_chapters) {
2643 o->chapters_input_file = i;
2647 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2648 o->chapters_input_file);
2652 if (o->chapters_input_file >= 0)
2653 copy_chapters(input_files[o->chapters_input_file], of,
2654 !o->metadata_chapters_manual);
2656 /* copy global metadata by default */
2657 if (!o->metadata_global_manual && nb_input_files){
2658 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2659 AV_DICT_DONT_OVERWRITE);
2660 if(o->recording_time != INT64_MAX)
2661 av_dict_set(&oc->metadata, "duration", NULL, 0);
2662 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2663 av_dict_set(&oc->metadata, "company_name", NULL, 0);
2664 av_dict_set(&oc->metadata, "product_name", NULL, 0);
2665 av_dict_set(&oc->metadata, "product_version", NULL, 0);
2667 if (!o->metadata_streams_manual)
2668 for (i = of->ost_index; i < nb_output_streams; i++) {
2670 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2672 ist = input_streams[output_streams[i]->source_index];
2673 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2674 if (!output_streams[i]->stream_copy) {
2675 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2679 /* process manually set programs */
2680 for (i = 0; i < o->nb_program; i++) {
2681 const char *p = o->program[i].u.str;
2686 const char *p2 = av_get_token(&p, ":");
2687 const char *to_dealloc = p2;
2694 key = av_get_token(&p2, "=");
2696 av_freep(&to_dealloc);
2702 if (!strcmp(key, "program_num"))
2703 progid = strtol(p2, NULL, 0);
2704 av_freep(&to_dealloc);
2708 program = av_new_program(oc, progid);
2710 p = o->program[i].u.str;
2712 const char *p2 = av_get_token(&p, ":");
2713 const char *to_dealloc = p2;
2719 key = av_get_token(&p2, "=");
2721 av_log(NULL, AV_LOG_FATAL,
2722 "No '=' character in program string %s.\n",
2730 if (!strcmp(key, "title")) {
2731 av_dict_set(&program->metadata, "title", p2, 0);
2732 } else if (!strcmp(key, "program_num")) {
2733 } else if (!strcmp(key, "st")) {
2734 int st_num = strtol(p2, NULL, 0);
2735 av_program_add_stream_index(oc, progid, st_num);
2737 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2740 av_freep(&to_dealloc);
2745 /* process manually set metadata */
2746 for (i = 0; i < o->nb_metadata; i++) {
2749 const char *stream_spec;
2750 int index = 0, j, ret = 0;
2752 val = strchr(o->metadata[i].u.str, '=');
2754 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2755 o->metadata[i].u.str);
2760 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2762 for (j = 0; j < oc->nb_streams; j++) {
2763 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2764 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2765 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2767 double theta = av_strtod(val, &tail);
2769 ost->rotate_overridden = 1;
2770 ost->rotate_override_value = theta;
2773 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2785 if (index < 0 || index >= oc->nb_chapters) {
2786 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2789 m = &oc->chapters[index]->metadata;
2792 if (index < 0 || index >= oc->nb_programs) {
2793 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2796 m = &oc->programs[index]->metadata;
2799 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2802 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2809 static int opt_target(void *optctx, const char *opt, const char *arg)
2811 OptionsContext *o = optctx;
2812 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2813 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2815 if (!strncmp(arg, "pal-", 4)) {
2818 } else if (!strncmp(arg, "ntsc-", 5)) {
2821 } else if (!strncmp(arg, "film-", 5)) {
2825 /* Try to determine PAL/NTSC by peeking in the input files */
2826 if (nb_input_files) {
2828 for (j = 0; j < nb_input_files; j++) {
2829 for (i = 0; i < input_files[j]->nb_streams; i++) {
2830 AVStream *st = input_files[j]->ctx->streams[i];
2832 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2834 fr = st->time_base.den * 1000LL / st->time_base.num;
2838 } else if ((fr == 29970) || (fr == 23976)) {
2843 if (norm != UNKNOWN)
2847 if (norm != UNKNOWN)
2848 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2851 if (norm == UNKNOWN) {
2852 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2853 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2854 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2858 if (!strcmp(arg, "vcd")) {
2859 opt_video_codec(o, "c:v", "mpeg1video");
2860 opt_audio_codec(o, "c:a", "mp2");
2861 parse_option(o, "f", "vcd", options);
2863 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2864 parse_option(o, "r", frame_rates[norm], options);
2865 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2867 opt_default(NULL, "b:v", "1150000");
2868 opt_default(NULL, "maxrate:v", "1150000");
2869 opt_default(NULL, "minrate:v", "1150000");
2870 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2872 opt_default(NULL, "b:a", "224000");
2873 parse_option(o, "ar", "44100", options);
2874 parse_option(o, "ac", "2", options);
2876 opt_default(NULL, "packetsize", "2324");
2877 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2879 /* We have to offset the PTS, so that it is consistent with the SCR.
2880 SCR starts at 36000, but the first two packs contain only padding
2881 and the first pack from the other stream, respectively, may also have
2882 been written before.
2883 So the real data starts at SCR 36000+3*1200. */
2884 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2885 } else if (!strcmp(arg, "svcd")) {
2887 opt_video_codec(o, "c:v", "mpeg2video");
2888 opt_audio_codec(o, "c:a", "mp2");
2889 parse_option(o, "f", "svcd", options);
2891 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2892 parse_option(o, "r", frame_rates[norm], options);
2893 parse_option(o, "pix_fmt", "yuv420p", options);
2894 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2896 opt_default(NULL, "b:v", "2040000");
2897 opt_default(NULL, "maxrate:v", "2516000");
2898 opt_default(NULL, "minrate:v", "0"); // 1145000;
2899 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2900 opt_default(NULL, "scan_offset", "1");
2902 opt_default(NULL, "b:a", "224000");
2903 parse_option(o, "ar", "44100", options);
2905 opt_default(NULL, "packetsize", "2324");
2907 } else if (!strcmp(arg, "dvd")) {
2909 opt_video_codec(o, "c:v", "mpeg2video");
2910 opt_audio_codec(o, "c:a", "ac3");
2911 parse_option(o, "f", "dvd", options);
2913 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2914 parse_option(o, "r", frame_rates[norm], options);
2915 parse_option(o, "pix_fmt", "yuv420p", options);
2916 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2918 opt_default(NULL, "b:v", "6000000");
2919 opt_default(NULL, "maxrate:v", "9000000");
2920 opt_default(NULL, "minrate:v", "0"); // 1500000;
2921 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2923 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2924 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2926 opt_default(NULL, "b:a", "448000");
2927 parse_option(o, "ar", "48000", options);
2929 } else if (!strncmp(arg, "dv", 2)) {
2931 parse_option(o, "f", "dv", options);
2933 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2934 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2935 norm == PAL ? "yuv420p" : "yuv411p", options);
2936 parse_option(o, "r", frame_rates[norm], options);
2938 parse_option(o, "ar", "48000", options);
2939 parse_option(o, "ac", "2", options);
2942 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2943 return AVERROR(EINVAL);
2946 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2947 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2952 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2954 av_free (vstats_filename);
2955 vstats_filename = av_strdup (arg);
2959 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2962 time_t today2 = time(NULL);
2963 struct tm *today = localtime(&today2);
2965 if (!today) { // maybe tomorrow
2966 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2970 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2972 return opt_vstats_file(NULL, opt, filename);
2975 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2977 OptionsContext *o = optctx;
2978 return parse_option(o, "frames:v", arg, options);
2981 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2983 OptionsContext *o = optctx;
2984 return parse_option(o, "frames:a", arg, options);
2987 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2989 OptionsContext *o = optctx;
2990 return parse_option(o, "frames:d", arg, options);
2993 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2996 AVDictionary *cbak = codec_opts;
2997 AVDictionary *fbak = format_opts;
3001 ret = opt_default(NULL, opt, arg);
3003 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
3004 av_dict_copy(&o->g->format_opts, format_opts, 0);
3005 av_dict_free(&codec_opts);
3006 av_dict_free(&format_opts);
3013 static int opt_preset(void *optctx, const char *opt, const char *arg)
3015 OptionsContext *o = optctx;
3017 char filename[1000], line[1000], tmp_line[1000];
3018 const char *codec_name = NULL;
3022 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3024 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3025 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3026 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3028 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3032 while (fgets(line, sizeof(line), f)) {
3033 char *key = tmp_line, *value, *endptr;
3035 if (strcspn(line, "#\n\r") == 0)
3037 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3038 if (!av_strtok(key, "=", &value) ||
3039 !av_strtok(value, "\r\n", &endptr)) {
3040 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3043 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3045 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3046 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3047 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3048 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3049 else if (opt_default_new(o, key, value) < 0) {
3050 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3051 filename, line, key, value);
3061 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3063 OptionsContext *o = optctx;
3065 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3067 return AVERROR(ENOMEM);
3068 ret = parse_option(o, s, arg, options);
3073 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3075 OptionsContext *o = optctx;
3077 if(!strcmp(opt, "ab")){
3078 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3080 } else if(!strcmp(opt, "b")){
3081 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3082 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3085 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3089 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3091 OptionsContext *o = optctx;
3094 if(!strcmp(opt, "qscale")){
3095 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3096 return parse_option(o, "q:v", arg, options);
3098 s = av_asprintf("q%s", opt + 6);
3100 return AVERROR(ENOMEM);
3101 ret = parse_option(o, s, arg, options);
3106 static int opt_profile(void *optctx, const char *opt, const char *arg)
3108 OptionsContext *o = optctx;
3109 if(!strcmp(opt, "profile")){
3110 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3111 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3114 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3118 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3120 OptionsContext *o = optctx;
3121 return parse_option(o, "filter:v", arg, options);
3124 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3126 OptionsContext *o = optctx;
3127 return parse_option(o, "filter:a", arg, options);
3130 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3132 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3133 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3134 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3135 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3137 if (video_sync_method == VSYNC_AUTO)
3138 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3142 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3144 OptionsContext *o = optctx;
3146 char *tcr = av_asprintf("timecode=%s", arg);
3148 return AVERROR(ENOMEM);
3149 ret = parse_option(o, "metadata:g", tcr, options);
3151 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3156 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3158 OptionsContext *o = optctx;
3159 char layout_str[32];
3162 int ret, channels, ac_str_size;
3165 layout = av_get_channel_layout(arg);
3167 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3168 return AVERROR(EINVAL);
3170 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3171 ret = opt_default_new(o, opt, layout_str);
3175 /* set 'ac' option based on channel layout */
3176 channels = av_get_channel_layout_nb_channels(layout);
3177 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3178 stream_str = strchr(opt, ':');
3179 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3180 ac_str = av_mallocz(ac_str_size);
3182 return AVERROR(ENOMEM);
3183 av_strlcpy(ac_str, "ac", 3);
3185 av_strlcat(ac_str, stream_str, ac_str_size);
3186 ret = parse_option(o, ac_str, layout_str, options);
3192 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3194 OptionsContext *o = optctx;
3195 return parse_option(o, "q:a", arg, options);
3198 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3200 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3201 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3202 return AVERROR(ENOMEM);
3203 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3204 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3205 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3206 return AVERROR(ENOMEM);
3208 input_stream_potentially_available = 1;
3213 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3215 uint8_t *graph_desc = read_file(arg);
3217 return AVERROR(EINVAL);
3219 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3220 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3221 return AVERROR(ENOMEM);
3222 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3223 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3225 input_stream_potentially_available = 1;
3230 void show_help_default(const char *opt, const char *arg)
3232 /* per-file options have at least one of those set */
3233 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3234 int show_advanced = 0, show_avoptions = 0;
3237 if (!strcmp(opt, "long"))
3239 else if (!strcmp(opt, "full"))
3240 show_advanced = show_avoptions = 1;
3242 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3247 printf("Getting help:\n"
3248 " -h -- print basic options\n"
3249 " -h long -- print more options\n"
3250 " -h full -- print all options (including all format and codec specific options, very long)\n"
3251 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3252 " See man %s for detailed description of the options.\n"
3253 "\n", program_name);
3255 show_help_options(options, "Print help / information / capabilities:",
3258 show_help_options(options, "Global options (affect whole program "
3259 "instead of just one file):",
3260 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3262 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3263 per_file | OPT_EXIT, 0);
3265 show_help_options(options, "Per-file main options:", 0,
3266 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3267 OPT_EXIT, per_file);
3269 show_help_options(options, "Advanced per-file options:",
3270 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3272 show_help_options(options, "Video options:",
3273 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3275 show_help_options(options, "Advanced Video options:",
3276 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3278 show_help_options(options, "Audio options:",
3279 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3281 show_help_options(options, "Advanced Audio options:",
3282 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3283 show_help_options(options, "Subtitle options:",
3284 OPT_SUBTITLE, 0, 0);
3287 if (show_avoptions) {
3288 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3289 show_help_children(avcodec_get_class(), flags);
3290 show_help_children(avformat_get_class(), flags);
3292 show_help_children(sws_get_class(), flags);
3294 #if CONFIG_SWRESAMPLE
3295 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3297 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3298 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3302 void show_usage(void)
3304 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3305 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3306 av_log(NULL, AV_LOG_INFO, "\n");
3314 static const OptionGroupDef groups[] = {
3315 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3316 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3319 static int open_files(OptionGroupList *l, const char *inout,
3320 int (*open_file)(OptionsContext*, const char*))
3324 for (i = 0; i < l->nb_groups; i++) {
3325 OptionGroup *g = &l->groups[i];
3331 ret = parse_optgroup(&o, g);
3333 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3334 "%s.\n", inout, g->arg);
3339 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3340 ret = open_file(&o, g->arg);
3343 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3347 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3353 int ffmpeg_parse_options(int argc, char **argv)
3355 OptionParseContext octx;
3359 memset(&octx, 0, sizeof(octx));
3361 /* split the commandline into an internal representation */
3362 ret = split_commandline(&octx, argc, argv, options, groups,
3363 FF_ARRAY_ELEMS(groups));
3365 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3369 /* apply global options */
3370 ret = parse_optgroup(NULL, &octx.global_opts);
3372 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3376 /* configure terminal and setup signal handlers */
3379 /* open input files */
3380 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3382 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3386 /* create the complex filtergraphs */
3387 ret = init_complex_filters();
3389 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3393 /* open output files */
3394 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3396 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3400 check_filter_outputs();
3403 uninit_parse_context(&octx);
3405 av_strerror(ret, error, sizeof(error));
3406 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3411 static int opt_progress(void *optctx, const char *opt, const char *arg)
3413 AVIOContext *avio = NULL;
3416 if (!strcmp(arg, "-"))
3418 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3420 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3421 arg, av_err2str(ret));
3424 progress_avio = avio;
3428 #define OFFSET(x) offsetof(OptionsContext, x)
3429 const OptionDef options[] = {
3431 CMDUTILS_COMMON_OPTIONS
3432 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3433 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3434 "force format", "fmt" },
3435 { "y", OPT_BOOL, { &file_overwrite },
3436 "overwrite output files" },
3437 { "n", OPT_BOOL, { &no_file_overwrite },
3438 "never overwrite output files" },
3439 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3440 "Ignore unknown stream types" },
3441 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3442 "Copy unknown stream types" },
3443 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3444 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3445 "codec name", "codec" },
3446 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3447 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3448 "codec name", "codec" },
3449 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3450 OPT_OUTPUT, { .off = OFFSET(presets) },
3451 "preset name", "preset" },
3452 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3453 OPT_OUTPUT, { .func_arg = opt_map },
3454 "set input stream mapping",
3455 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3456 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3457 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3458 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3459 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3460 "set metadata information of outfile from infile",
3461 "outfile[,metadata]:infile[,metadata]" },
3462 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3463 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3464 "set chapters mapping", "input_file_index" },
3465 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3466 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3467 "record or transcode \"duration\" seconds of audio/video",
3469 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3470 "record or transcode stop time", "time_stop" },
3471 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3472 "set the limit file size in bytes", "limit_size" },
3473 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3474 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3475 "set the start time offset", "time_off" },
3476 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3477 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3478 "set the start time offset relative to EOF", "time_off" },
3479 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3480 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3481 "enable/disable seeking by timestamp with -ss" },
3482 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3483 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3484 "enable/disable accurate seeking with -ss" },
3485 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3486 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3487 "set the input ts offset", "time_off" },
3488 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3489 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3490 "set the input ts scale", "scale" },
3491 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3492 "set the recording timestamp ('now' to set the current time)", "time" },
3493 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3494 "add metadata", "string=string" },
3495 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3496 "add program with specified streams", "title=string:st=number..." },
3497 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3498 OPT_OUTPUT, { .func_arg = opt_data_frames },
3499 "set the number of data frames to output", "number" },
3500 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3501 "add timings for benchmarking" },
3502 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3503 "add timings for each task" },
3504 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3505 "write program-readable progress information", "url" },
3506 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3507 "enable or disable interaction on standard input" },
3508 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3509 "set max runtime in seconds in CPU user time", "limit" },
3510 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3511 "dump each input packet" },
3512 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3513 "when dumping packets, also dump the payload" },
3514 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3515 OPT_INPUT, { .off = OFFSET(rate_emu) },
3516 "read input at native frame rate", "" },
3517 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3518 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3519 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3520 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3521 "video sync method", "" },
3522 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3523 "frame drop threshold", "" },
3524 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3525 "audio sync method", "" },
3526 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3527 "audio drift threshold", "threshold" },
3528 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3529 "copy timestamps" },
3530 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3531 "shift input timestamps to start at 0 when using copyts" },
3532 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3533 "copy input stream time base when stream copying", "mode" },
3534 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3535 OPT_OUTPUT, { .off = OFFSET(shortest) },
3536 "finish encoding within shortest input" },
3537 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3538 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3540 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3541 OPT_OUTPUT, { .off = OFFSET(apad) },
3543 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3544 "timestamp discontinuity delta threshold", "threshold" },
3545 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3546 "timestamp error delta threshold", "threshold" },
3547 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3548 "exit on error", "error" },
3549 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3550 "abort on the specified condition flags", "flags" },
3551 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3552 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3553 "copy initial non-keyframes" },
3554 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3555 "copy or discard frames before start time" },
3556 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3557 "set the number of frames to output", "number" },
3558 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3559 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3560 "force codec tag/fourcc", "fourcc/tag" },
3561 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3562 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3563 "use fixed quality scale (VBR)", "q" },
3564 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3565 OPT_OUTPUT, { .func_arg = opt_qscale },
3566 "use fixed quality scale (VBR)", "q" },
3567 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3568 "set profile", "profile" },
3569 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3570 "set stream filtergraph", "filter_graph" },
3571 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3572 "number of non-complex filter threads" },
3573 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3574 "read stream filtergraph description from a file", "filename" },
3575 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3576 "reinit filtergraph on input parameter changes", "" },
3577 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3578 "create a complex filtergraph", "graph_description" },
3579 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3580 "number of threads for -filter_complex" },
3581 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3582 "create a complex filtergraph", "graph_description" },
3583 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3584 "read complex filtergraph description from a file", "filename" },
3585 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3586 "enable automatic conversion filters globally" },
3587 { "stats", OPT_BOOL, { &print_stats },
3588 "print progress report during encoding", },
3589 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
3590 "set the period at which ffmpeg updates stats and -progress output", "time" },
3591 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3592 OPT_OUTPUT, { .func_arg = opt_attach },
3593 "add an attachment to the output file", "filename" },
3594 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3595 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3596 "extract an attachment into a file", "filename" },
3597 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3598 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3599 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3600 "print timestamp debugging info" },
3601 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3602 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3603 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3604 OPT_INPUT, { .off = OFFSET(discard) },
3606 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3607 OPT_OUTPUT, { .off = OFFSET(disposition) },
3608 "disposition", "" },
3609 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3610 { .off = OFFSET(thread_queue_size) },
3611 "set the maximum number of queued packets from the demuxer" },
3612 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3613 "read and decode the streams to fill missing information with heuristics" },
3616 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3617 "set the number of video frames to output", "number" },
3618 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3619 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3620 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3621 { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3622 OPT_OUTPUT, { .off = OFFSET(max_frame_rates) },
3623 "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3624 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3625 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3626 "set frame size (WxH or abbreviation)", "size" },
3627 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3628 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3629 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3630 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3631 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3632 "set pixel format", "format" },
3633 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3634 "set the number of bits per raw sample", "number" },
3635 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3636 "deprecated use -g 1" },
3637 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3639 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3640 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3641 "rate control override for specific intervals", "override" },
3642 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3643 OPT_OUTPUT, { .func_arg = opt_video_codec },
3644 "force video codec ('copy' to copy stream)", "codec" },
3645 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3647 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3649 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3650 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3651 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3652 "select the pass number (1 to 3)", "n" },
3653 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3654 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3655 "select two pass log file name prefix", "prefix" },
3656 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3657 "this option is deprecated, use the yadif filter instead" },
3658 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3659 "calculate PSNR of compressed frames" },
3660 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3661 "dump video coding statistics to file" },
3662 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3663 "dump video coding statistics to file", "file" },
3664 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3665 "Version of the vstats format to use."},
3666 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3667 "set video filters", "filter_graph" },
3668 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3669 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3670 "specify intra matrix coeffs", "matrix" },
3671 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3672 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3673 "specify inter matrix coeffs", "matrix" },
3674 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3675 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3676 "specify intra matrix coeffs", "matrix" },
3677 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3678 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3679 "top=1/bottom=0/auto=-1 field first", "" },
3680 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3681 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3682 "force video tag/fourcc", "fourcc/tag" },
3683 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3684 "show QP histogram" },
3685 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3686 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3687 "force the selected framerate, disable the best supported framerate selection" },
3688 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3689 OPT_OUTPUT, { .func_arg = opt_streamid },
3690 "set the value of an outfile streamid", "streamIndex:value" },
3691 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3692 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3693 "force key frames at specified timestamps", "timestamps" },
3694 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3695 "audio bitrate (please use -b:a)", "bitrate" },
3696 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3697 "video bitrate (please use -b:v)", "bitrate" },
3698 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3699 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3700 "use HW accelerated decoding", "hwaccel name" },
3701 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3702 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3703 "select a device for HW acceleration", "devicename" },
3704 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3705 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3706 "select output format used with HW accelerated decoding", "format" },
3707 #if CONFIG_VIDEOTOOLBOX
3708 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3710 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3711 "show available HW acceleration methods" },
3712 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3713 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3714 "automatically insert correct rotate filters" },
3715 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3716 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3717 "automatically insert a scale filter at the end of the filter graph" },
3720 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3721 "set the number of audio frames to output", "number" },
3722 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3723 "set audio quality (codec-specific)", "quality", },
3724 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3725 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3726 "set audio sampling rate (in Hz)", "rate" },
3727 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3729 "set number of audio channels", "channels" },
3730 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3732 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3733 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3734 "force audio codec ('copy' to copy stream)", "codec" },
3735 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3736 OPT_OUTPUT, { .func_arg = opt_old2new },
3737 "force audio tag/fourcc", "fourcc/tag" },
3738 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3739 "change audio volume (256=normal)" , "volume" },
3740 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3741 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3742 "set sample format", "format" },
3743 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3744 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3745 "set channel layout", "layout" },
3746 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3747 "set audio filters", "filter_graph" },
3748 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3749 "set the maximum number of channels to try to guess the channel layout" },
3751 /* subtitle options */
3752 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3753 "disable subtitle" },
3754 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3755 "force subtitle codec ('copy' to copy stream)", "codec" },
3756 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3757 , "force subtitle tag/fourcc", "fourcc/tag" },
3758 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3759 "fix subtitles duration" },
3760 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3761 "set canvas size (WxH or abbreviation)", "size" },
3764 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3765 "deprecated, use -channel", "channel" },
3766 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3767 "deprecated, use -standard", "standard" },
3768 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3771 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3772 "set the maximum demux-decode delay", "seconds" },
3773 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3774 "set the initial demux-decode delay", "seconds" },
3775 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3776 "specify a file in which to print sdp information", "file" },
3778 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3779 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3780 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3781 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3782 "two special values are defined - "
3783 "0 = use frame rate (video) or sample rate (audio),"
3784 "-1 = match source time base", "ratio" },
3786 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3787 "A comma-separated list of bitstream filters", "bitstream_filters" },
3788 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3789 "deprecated", "audio bitstream_filters" },
3790 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3791 "deprecated", "video bitstream_filters" },
3793 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3794 "set the audio options to the indicated preset", "preset" },
3795 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3796 "set the video options to the indicated preset", "preset" },
3797 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3798 "set the subtitle options to the indicated preset", "preset" },
3799 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3800 "set options from indicated preset file", "filename" },
3802 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3803 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3804 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3805 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3807 /* data codec support */
3808 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3809 "force data codec ('copy' to copy stream)", "codec" },
3810 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3814 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3815 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3819 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3820 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3823 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3824 "initialise hardware device", "args" },
3825 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3826 "set hardware device used when filtering", "device" },