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 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 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
776 st->codecpar->codec_id = codec->id;
779 return avcodec_find_decoder(st->codecpar->codec_id);
782 /* Add all the streams from the given input file to the global
783 * list of input streams. */
784 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
788 for (i = 0; i < ic->nb_streams; i++) {
789 AVStream *st = ic->streams[i];
790 AVCodecParameters *par = st->codecpar;
791 InputStream *ist = av_mallocz(sizeof(*ist));
792 char *framerate = NULL, *hwaccel_device = NULL;
793 const char *hwaccel = NULL;
794 char *hwaccel_output_format = NULL;
795 char *codec_tag = NULL;
797 char *discard_str = NULL;
798 const AVClass *cc = avcodec_get_class();
799 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
804 GROW_ARRAY(input_streams, nb_input_streams);
805 input_streams[nb_input_streams - 1] = ist;
808 ist->file_index = nb_input_files;
810 st->discard = AVDISCARD_ALL;
812 ist->min_pts = INT64_MAX;
813 ist->max_pts = INT64_MIN;
816 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
819 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
821 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
823 uint32_t tag = strtol(codec_tag, &next, 0);
825 tag = AV_RL32(codec_tag);
826 st->codecpar->codec_tag = tag;
829 ist->dec = choose_decoder(o, ic, st);
830 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
832 ist->reinit_filters = -1;
833 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
835 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
836 ist->user_set_discard = AVDISCARD_NONE;
838 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
839 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
840 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
841 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
842 ist->user_set_discard = AVDISCARD_ALL;
844 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
845 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
850 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
852 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
854 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
858 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
860 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
865 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
867 switch (par->codec_type) {
868 case AVMEDIA_TYPE_VIDEO:
870 ist->dec = avcodec_find_decoder(par->codec_id);
872 // avformat_find_stream_info() doesn't set this for us anymore.
873 ist->dec_ctx->framerate = st->avg_frame_rate;
875 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
876 if (framerate && av_parse_video_rate(&ist->framerate,
878 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
883 ist->top_field_first = -1;
884 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
886 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
887 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
888 hwaccel_output_format, ic, st);
890 if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
891 av_log(NULL, AV_LOG_WARNING,
892 "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
893 "with old commandlines. This behaviour is DEPRECATED and will be removed "
894 "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
895 ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
896 } else if (hwaccel_output_format) {
897 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
898 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
899 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
900 "format: %s", hwaccel_output_format);
903 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
907 // The NVDEC hwaccels use a CUDA device, so remap the name here.
908 if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
911 if (!strcmp(hwaccel, "none"))
912 ist->hwaccel_id = HWACCEL_NONE;
913 else if (!strcmp(hwaccel, "auto"))
914 ist->hwaccel_id = HWACCEL_AUTO;
916 enum AVHWDeviceType type;
918 for (i = 0; hwaccels[i].name; i++) {
919 if (!strcmp(hwaccels[i].name, hwaccel)) {
920 ist->hwaccel_id = hwaccels[i].id;
925 if (!ist->hwaccel_id) {
926 type = av_hwdevice_find_type_by_name(hwaccel);
927 if (type != AV_HWDEVICE_TYPE_NONE) {
928 ist->hwaccel_id = HWACCEL_GENERIC;
929 ist->hwaccel_device_type = type;
933 if (!ist->hwaccel_id) {
934 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
936 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
937 type = AV_HWDEVICE_TYPE_NONE;
938 while ((type = av_hwdevice_iterate_types(type)) !=
939 AV_HWDEVICE_TYPE_NONE)
940 av_log(NULL, AV_LOG_FATAL, "%s ",
941 av_hwdevice_get_type_name(type));
942 av_log(NULL, AV_LOG_FATAL, "\n");
948 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
949 if (hwaccel_device) {
950 ist->hwaccel_device = av_strdup(hwaccel_device);
951 if (!ist->hwaccel_device)
955 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
958 case AVMEDIA_TYPE_AUDIO:
959 ist->guess_layout_max = INT_MAX;
960 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
961 guess_input_channel_layout(ist);
963 case AVMEDIA_TYPE_DATA:
964 case AVMEDIA_TYPE_SUBTITLE: {
965 char *canvas_size = NULL;
967 ist->dec = avcodec_find_decoder(par->codec_id);
968 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
969 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
971 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
972 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
977 case AVMEDIA_TYPE_ATTACHMENT:
978 case AVMEDIA_TYPE_UNKNOWN:
984 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
986 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
992 static void assert_file_overwrite(const char *filename)
994 const char *proto_name = avio_find_protocol_name(filename);
996 if (file_overwrite && no_file_overwrite) {
997 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
1001 if (!file_overwrite) {
1002 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
1003 if (stdin_interaction && !no_file_overwrite) {
1004 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
1007 signal(SIGINT, SIG_DFL);
1008 if (!read_yesno()) {
1009 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1015 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1021 if (proto_name && !strcmp(proto_name, "file")) {
1022 for (int i = 0; i < nb_input_files; i++) {
1023 InputFile *file = input_files[i];
1024 if (file->ctx->iformat->flags & AVFMT_NOFILE)
1026 if (!strcmp(filename, file->ctx->url)) {
1027 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1028 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1035 static void dump_attachment(AVStream *st, const char *filename)
1038 AVIOContext *out = NULL;
1039 AVDictionaryEntry *e;
1041 if (!st->codecpar->extradata_size) {
1042 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1043 nb_input_files - 1, st->index);
1046 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1047 filename = e->value;
1049 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1050 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1054 assert_file_overwrite(filename);
1056 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1057 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1062 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1067 static int open_input_file(OptionsContext *o, const char *filename)
1070 AVFormatContext *ic;
1071 AVInputFormat *file_iformat = NULL;
1074 AVDictionary *unused_opts = NULL;
1075 AVDictionaryEntry *e = NULL;
1076 char * video_codec_name = NULL;
1077 char * audio_codec_name = NULL;
1078 char *subtitle_codec_name = NULL;
1079 char * data_codec_name = NULL;
1080 int scan_all_pmts_set = 0;
1082 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1083 o->stop_time = INT64_MAX;
1084 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1087 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1088 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1089 if (o->stop_time <= start_time) {
1090 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1093 o->recording_time = o->stop_time - start_time;
1098 if (!(file_iformat = av_find_input_format(o->format))) {
1099 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1104 if (!strcmp(filename, "-"))
1107 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1108 strcmp(filename, "/dev/stdin");
1110 /* get default parameters from command line */
1111 ic = avformat_alloc_context();
1113 print_error(filename, AVERROR(ENOMEM));
1116 if (o->nb_audio_sample_rate) {
1117 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1119 if (o->nb_audio_channels) {
1120 /* because we set audio_channels based on both the "ac" and
1121 * "channel_layout" options, we need to check that the specified
1122 * demuxer actually has the "channels" option before setting it */
1123 if (file_iformat && file_iformat->priv_class &&
1124 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1125 AV_OPT_SEARCH_FAKE_OBJ)) {
1126 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1129 if (o->nb_frame_rates) {
1130 /* set the format-level framerate option;
1131 * this is important for video grabbers, e.g. x11 */
1132 if (file_iformat && file_iformat->priv_class &&
1133 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1134 AV_OPT_SEARCH_FAKE_OBJ)) {
1135 av_dict_set(&o->g->format_opts, "framerate",
1136 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1139 if (o->nb_frame_sizes) {
1140 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1142 if (o->nb_frame_pix_fmts)
1143 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1145 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1146 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1147 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1148 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1150 if (video_codec_name)
1151 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1152 if (audio_codec_name)
1153 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1154 if (subtitle_codec_name)
1155 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1156 if (data_codec_name)
1157 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1159 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1160 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1161 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1162 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1164 ic->flags |= AVFMT_FLAG_NONBLOCK;
1166 ic->flags |= AVFMT_FLAG_BITEXACT;
1167 ic->interrupt_callback = int_cb;
1169 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1170 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1171 scan_all_pmts_set = 1;
1173 /* open the input file with generic avformat function */
1174 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1176 print_error(filename, err);
1177 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1178 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1181 if (scan_all_pmts_set)
1182 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1183 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1184 assert_avoptions(o->g->format_opts);
1186 /* apply forced codec ids */
1187 for (i = 0; i < ic->nb_streams; i++)
1188 choose_decoder(o, ic, ic->streams[i]);
1190 if (find_stream_info) {
1191 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1192 int orig_nb_streams = ic->nb_streams;
1194 /* If not enough info to get the stream parameters, we decode the
1195 first frames to get it. (used in mpeg case for example) */
1196 ret = avformat_find_stream_info(ic, opts);
1198 for (i = 0; i < orig_nb_streams; i++)
1199 av_dict_free(&opts[i]);
1203 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1204 if (ic->nb_streams == 0) {
1205 avformat_close_input(&ic);
1211 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1212 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1213 o->start_time_eof = AV_NOPTS_VALUE;
1216 if (o->start_time_eof != AV_NOPTS_VALUE) {
1217 if (o->start_time_eof >= 0) {
1218 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1221 if (ic->duration > 0) {
1222 o->start_time = o->start_time_eof + ic->duration;
1223 if (o->start_time < 0) {
1224 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1225 o->start_time = AV_NOPTS_VALUE;
1228 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1230 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1231 /* add the stream start time */
1232 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1233 timestamp += ic->start_time;
1235 /* if seeking requested, we execute it */
1236 if (o->start_time != AV_NOPTS_VALUE) {
1237 int64_t seek_timestamp = timestamp;
1239 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1240 int dts_heuristic = 0;
1241 for (i=0; i<ic->nb_streams; i++) {
1242 const AVCodecParameters *par = ic->streams[i]->codecpar;
1243 if (par->video_delay) {
1248 if (dts_heuristic) {
1249 seek_timestamp -= 3*AV_TIME_BASE / 23;
1252 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1254 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1255 filename, (double)timestamp / AV_TIME_BASE);
1259 /* update the current parameters so that they match the one of the input stream */
1260 add_input_streams(o, ic);
1262 /* dump the file content */
1263 av_dump_format(ic, nb_input_files, filename, 0);
1265 GROW_ARRAY(input_files, nb_input_files);
1266 f = av_mallocz(sizeof(*f));
1269 input_files[nb_input_files - 1] = f;
1272 f->ist_index = nb_input_streams - ic->nb_streams;
1273 f->start_time = o->start_time;
1274 f->recording_time = o->recording_time;
1275 f->input_ts_offset = o->input_ts_offset;
1276 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1277 f->nb_streams = ic->nb_streams;
1278 f->rate_emu = o->rate_emu;
1279 f->accurate_seek = o->accurate_seek;
1282 f->time_base = (AVRational){ 1, 1 };
1284 f->thread_queue_size = o->thread_queue_size;
1287 /* check if all codec options have been used */
1288 unused_opts = strip_specifiers(o->g->codec_opts);
1289 for (i = f->ist_index; i < nb_input_streams; i++) {
1291 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1292 AV_DICT_IGNORE_SUFFIX)))
1293 av_dict_set(&unused_opts, e->key, NULL, 0);
1297 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1298 const AVClass *class = avcodec_get_class();
1299 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1300 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1301 const AVClass *fclass = avformat_get_class();
1302 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1303 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1304 if (!option || foption)
1308 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1309 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1310 "input file #%d (%s) is not a decoding option.\n", e->key,
1311 option->help ? option->help : "", nb_input_files - 1,
1316 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1317 "input file #%d (%s) has not been used for any stream. The most "
1318 "likely reason is either wrong type (e.g. a video option with "
1319 "no video streams) or that it is a private option of some decoder "
1320 "which was not actually used for any stream.\n", e->key,
1321 option->help ? option->help : "", nb_input_files - 1, filename);
1323 av_dict_free(&unused_opts);
1325 for (i = 0; i < o->nb_dump_attachment; i++) {
1328 for (j = 0; j < ic->nb_streams; j++) {
1329 AVStream *st = ic->streams[j];
1331 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1332 dump_attachment(st, o->dump_attachment[i].u.str);
1336 input_stream_potentially_available = 1;
1341 static uint8_t *get_line(AVIOContext *s)
1347 if (avio_open_dyn_buf(&line) < 0) {
1348 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1352 while ((c = avio_r8(s)) && c != '\n')
1355 avio_close_dyn_buf(line, &buf);
1360 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1363 char filename[1000];
1364 const char *base[3] = { getenv("AVCONV_DATADIR"),
1369 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1373 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1374 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1375 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1378 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1379 i != 1 ? "" : "/.avconv", preset_name);
1380 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1386 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1388 enum AVMediaType type = ost->st->codecpar->codec_type;
1389 char *codec_name = NULL;
1391 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1392 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1394 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1395 NULL, ost->st->codecpar->codec_type);
1396 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1398 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1399 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1400 "probably disabled. Please choose an encoder manually.\n",
1401 ost->file_index, ost->index, s->oformat->name,
1402 avcodec_get_name(ost->st->codecpar->codec_id));
1403 return AVERROR_ENCODER_NOT_FOUND;
1405 } else if (!strcmp(codec_name, "copy"))
1406 ost->stream_copy = 1;
1408 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1409 ost->st->codecpar->codec_id = ost->enc->id;
1411 ost->encoding_needed = !ost->stream_copy;
1413 /* no encoding supported for other media types */
1414 ost->stream_copy = 1;
1415 ost->encoding_needed = 0;
1421 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1424 AVStream *st = avformat_new_stream(oc, NULL);
1425 int idx = oc->nb_streams - 1, ret = 0;
1426 const char *bsfs = NULL, *time_base = NULL;
1427 char *next, *codec_tag = NULL;
1432 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1436 if (oc->nb_streams - 1 < o->nb_streamid_map)
1437 st->id = o->streamid_map[oc->nb_streams - 1];
1439 GROW_ARRAY(output_streams, nb_output_streams);
1440 if (!(ost = av_mallocz(sizeof(*ost))))
1442 output_streams[nb_output_streams - 1] = ost;
1444 ost->file_index = nb_output_files - 1;
1447 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1448 st->codecpar->codec_type = type;
1450 ret = choose_encoder(o, oc, ost);
1452 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1453 "%d:%d\n", ost->file_index, ost->index);
1457 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1458 if (!ost->enc_ctx) {
1459 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1462 ost->enc_ctx->codec_type = type;
1464 ost->ref_par = avcodec_parameters_alloc();
1465 if (!ost->ref_par) {
1466 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1471 AVIOContext *s = NULL;
1472 char *buf = NULL, *arg = NULL, *preset = NULL;
1474 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1476 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1478 MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1479 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1482 if (!buf[0] || buf[0] == '#') {
1486 if (!(arg = strchr(buf, '='))) {
1487 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1491 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1493 } while (!s->eof_reached);
1497 av_log(NULL, AV_LOG_FATAL,
1498 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1499 preset, ost->file_index, ost->index);
1503 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1508 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1510 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1513 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1514 q.num <= 0 || q.den <= 0) {
1515 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1521 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1524 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1526 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1529 ost->enc_timebase = q;
1532 ost->max_frames = INT64_MAX;
1533 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1534 for (i = 0; i<o->nb_max_frames; i++) {
1535 char *p = o->max_frames[i].specifier;
1536 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1537 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1542 ost->copy_prior_start = -1;
1543 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1545 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1546 if (bsfs && *bsfs) {
1547 ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1549 av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1554 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1556 uint32_t tag = strtol(codec_tag, &next, 0);
1558 tag = AV_RL32(codec_tag);
1559 ost->st->codecpar->codec_tag =
1560 ost->enc_ctx->codec_tag = tag;
1563 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1565 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1566 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1569 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1570 ost->disposition = av_strdup(ost->disposition);
1572 ost->max_muxing_queue_size = 128;
1573 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1574 ost->max_muxing_queue_size *= sizeof(AVPacket);
1576 ost->muxing_queue_data_size = 0;
1578 ost->muxing_queue_data_threshold = 50*1024*1024;
1579 MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1581 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1582 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1584 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1586 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1587 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1588 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1590 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1592 ost->source_index = source_index;
1593 if (source_index >= 0) {
1594 ost->sync_ist = input_streams[source_index];
1595 input_streams[source_index]->discard = 0;
1596 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1598 ost->last_mux_dts = AV_NOPTS_VALUE;
1600 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1601 if (!ost->muxing_queue)
1607 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1610 const char *p = str;
1617 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1624 /* read file contents into a string */
1625 static uint8_t *read_file(const char *filename)
1627 AVIOContext *pb = NULL;
1628 AVIOContext *dyn_buf = NULL;
1629 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1630 uint8_t buf[1024], *str;
1633 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1637 ret = avio_open_dyn_buf(&dyn_buf);
1642 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1643 avio_write(dyn_buf, buf, ret);
1644 avio_w8(dyn_buf, 0);
1647 ret = avio_close_dyn_buf(dyn_buf, &str);
1653 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1656 AVStream *st = ost->st;
1658 if (ost->filters_script && ost->filters) {
1659 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1660 "output stream #%d:%d.\n", nb_output_files, st->index);
1664 if (ost->filters_script)
1665 return read_file(ost->filters_script);
1666 else if (ost->filters)
1667 return av_strdup(ost->filters);
1669 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1673 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1674 const OutputStream *ost, enum AVMediaType type)
1676 if (ost->filters_script || ost->filters) {
1677 av_log(NULL, AV_LOG_ERROR,
1678 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1679 "Filtering and streamcopy cannot be used together.\n",
1680 ost->filters ? "Filtergraph" : "Filtergraph script",
1681 ost->filters ? ost->filters : ost->filters_script,
1682 av_get_media_type_string(type), ost->file_index, ost->index);
1687 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1691 AVCodecContext *video_enc;
1692 char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
1694 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1696 video_enc = ost->enc_ctx;
1698 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1699 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1700 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1704 MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1705 if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1706 av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1710 if (frame_rate && max_frame_rate) {
1711 av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1715 if ((frame_rate || max_frame_rate) &&
1716 video_sync_method == VSYNC_PASSTHROUGH)
1717 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1719 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1720 if (frame_aspect_ratio) {
1722 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1723 q.num <= 0 || q.den <= 0) {
1724 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1727 ost->frame_aspect_ratio = q;
1730 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1731 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1733 if (!ost->stream_copy) {
1734 const char *p = NULL;
1735 char *frame_size = NULL;
1736 char *frame_pix_fmt = NULL;
1737 char *intra_matrix = NULL, *inter_matrix = NULL;
1738 char *chroma_intra_matrix = NULL;
1742 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1743 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1744 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1748 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1749 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1750 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1751 ost->keep_pix_fmt = 1;
1752 if (!*++frame_pix_fmt)
1753 frame_pix_fmt = NULL;
1755 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1756 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1759 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1762 video_enc->gop_size = 0;
1763 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1765 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1766 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1769 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1771 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1772 if (chroma_intra_matrix) {
1773 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1775 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1778 video_enc->chroma_intra_matrix = p;
1779 parse_matrix_coeffs(p, chroma_intra_matrix);
1781 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1783 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1784 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1787 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1790 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1791 for (i = 0; p; i++) {
1793 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1795 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1798 video_enc->rc_override =
1799 av_realloc_array(video_enc->rc_override,
1800 i + 1, sizeof(RcOverride));
1801 if (!video_enc->rc_override) {
1802 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1805 video_enc->rc_override[i].start_frame = start;
1806 video_enc->rc_override[i].end_frame = end;
1808 video_enc->rc_override[i].qscale = q;
1809 video_enc->rc_override[i].quality_factor = 1.0;
1812 video_enc->rc_override[i].qscale = 0;
1813 video_enc->rc_override[i].quality_factor = -q/100.0;
1818 video_enc->rc_override_count = i;
1821 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1824 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1827 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1828 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1831 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1832 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1836 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1837 if (ost->logfile_prefix &&
1838 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1842 char logfilename[1024];
1845 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1846 ost->logfile_prefix ? ost->logfile_prefix :
1847 DEFAULT_PASS_LOGFILENAME_PREFIX,
1849 if (!strcmp(ost->enc->name, "libx264")) {
1850 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1852 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1853 char *logbuffer = read_file(logfilename);
1856 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1860 video_enc->stats_in = logbuffer;
1862 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1863 f = av_fopen_utf8(logfilename, "wb");
1865 av_log(NULL, AV_LOG_FATAL,
1866 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1867 logfilename, strerror(errno));
1875 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1876 if (ost->forced_keyframes)
1877 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1879 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1881 ost->top_field_first = -1;
1882 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1885 ost->avfilter = get_ost_filters(o, oc, ost);
1889 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1892 if (ost->stream_copy)
1893 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1898 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1903 AVCodecContext *audio_enc;
1905 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1908 audio_enc = ost->enc_ctx;
1909 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1911 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1912 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1914 if (!ost->stream_copy) {
1915 char *sample_fmt = NULL;
1917 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1919 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1921 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1922 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1926 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1928 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1929 ost->apad = av_strdup(ost->apad);
1931 ost->avfilter = get_ost_filters(o, oc, ost);
1935 /* check for channel mapping for this audio stream */
1936 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1937 AudioChannelMap *map = &o->audio_channel_maps[n];
1938 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1939 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1942 if (map->channel_idx == -1) {
1944 } else if (ost->source_index < 0) {
1945 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1946 ost->file_index, ost->st->index);
1949 ist = input_streams[ost->source_index];
1952 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1953 if (av_reallocp_array(&ost->audio_channels_map,
1954 ost->audio_channels_mapped + 1,
1955 sizeof(*ost->audio_channels_map)
1959 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1965 if (ost->stream_copy)
1966 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1971 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1975 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1976 if (!ost->stream_copy) {
1977 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1984 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1988 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1989 if (!ost->stream_copy) {
1990 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1997 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1999 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2000 ost->stream_copy = 1;
2005 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2009 AVCodecContext *subtitle_enc;
2011 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2013 subtitle_enc = ost->enc_ctx;
2015 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2017 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2019 if (!ost->stream_copy) {
2020 char *frame_size = NULL;
2022 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2023 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2024 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2032 /* arg format is "output-stream-index:streamid-value". */
2033 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2035 OptionsContext *o = optctx;
2040 av_strlcpy(idx_str, arg, sizeof(idx_str));
2041 p = strchr(idx_str, ':');
2043 av_log(NULL, AV_LOG_FATAL,
2044 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2049 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2050 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2051 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2055 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2057 AVFormatContext *is = ifile->ctx;
2058 AVFormatContext *os = ofile->ctx;
2062 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2064 return AVERROR(ENOMEM);
2067 for (i = 0; i < is->nb_chapters; i++) {
2068 AVChapter *in_ch = is->chapters[i], *out_ch;
2069 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2070 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2071 AV_TIME_BASE_Q, in_ch->time_base);
2072 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2073 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2076 if (in_ch->end < ts_off)
2078 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2081 out_ch = av_mallocz(sizeof(AVChapter));
2083 return AVERROR(ENOMEM);
2085 out_ch->id = in_ch->id;
2086 out_ch->time_base = in_ch->time_base;
2087 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2088 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2091 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2093 os->chapters[os->nb_chapters++] = out_ch;
2098 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2099 AVFormatContext *oc)
2103 switch (ofilter->type) {
2104 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2105 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2107 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2112 ost->source_index = -1;
2113 ost->filter = ofilter;
2116 ofilter->format = -1;
2118 if (ost->stream_copy) {
2119 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2120 "which is fed from a complex filtergraph. Filtering and streamcopy "
2121 "cannot be used together.\n", ost->file_index, ost->index);
2125 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2126 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2127 av_log(NULL, AV_LOG_ERROR,
2128 "%s '%s' was specified through the %s option "
2129 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2130 "%s and -filter_complex cannot be used together for the same stream.\n",
2131 ost->filters ? "Filtergraph" : "Filtergraph script",
2132 ost->filters ? ost->filters : ost->filters_script,
2133 opt, ost->file_index, ost->index, opt);
2137 avfilter_inout_free(&ofilter->out_tmp);
2140 static int init_complex_filters(void)
2144 for (i = 0; i < nb_filtergraphs; i++) {
2145 ret = init_complex_filtergraph(filtergraphs[i]);
2152 static int open_output_file(OptionsContext *o, const char *filename)
2154 AVFormatContext *oc;
2159 AVDictionary *unused_opts = NULL;
2160 AVDictionaryEntry *e = NULL;
2161 int format_flags = 0;
2163 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2164 o->stop_time = INT64_MAX;
2165 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2168 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2169 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2170 if (o->stop_time <= start_time) {
2171 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2174 o->recording_time = o->stop_time - start_time;
2178 GROW_ARRAY(output_files, nb_output_files);
2179 of = av_mallocz(sizeof(*of));
2182 output_files[nb_output_files - 1] = of;
2184 of->ost_index = nb_output_streams;
2185 of->recording_time = o->recording_time;
2186 of->start_time = o->start_time;
2187 of->limit_filesize = o->limit_filesize;
2188 of->shortest = o->shortest;
2189 av_dict_copy(&of->opts, o->g->format_opts, 0);
2191 if (!strcmp(filename, "-"))
2194 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2196 print_error(filename, err);
2201 if (o->recording_time != INT64_MAX)
2202 oc->duration = o->recording_time;
2204 oc->interrupt_callback = int_cb;
2206 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2208 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2209 av_opt_eval_flags(oc, o, e->value, &format_flags);
2212 format_flags |= AVFMT_FLAG_BITEXACT;
2213 oc->flags |= AVFMT_FLAG_BITEXACT;
2216 /* create streams for all unlabeled output pads */
2217 for (i = 0; i < nb_filtergraphs; i++) {
2218 FilterGraph *fg = filtergraphs[i];
2219 for (j = 0; j < fg->nb_outputs; j++) {
2220 OutputFilter *ofilter = fg->outputs[j];
2222 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2225 switch (ofilter->type) {
2226 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2227 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2228 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2230 init_output_filter(ofilter, o, oc);
2234 if (!o->nb_stream_maps) {
2235 char *subtitle_codec_name = NULL;
2236 /* pick the "best" stream of each type */
2238 /* video: highest resolution */
2239 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2240 int best_score = 0, idx = -1;
2241 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2242 for (i = 0; i < nb_input_streams; i++) {
2244 ist = input_streams[i];
2245 score = ist->st->codecpar->width * ist->st->codecpar->height
2246 + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2247 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2248 if (ist->user_set_discard == AVDISCARD_ALL)
2250 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2252 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2253 score > best_score) {
2254 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2261 new_video_stream(o, oc, idx);
2264 /* audio: most channels */
2265 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2266 int best_score = 0, idx = -1;
2267 for (i = 0; i < nb_input_streams; i++) {
2269 ist = input_streams[i];
2270 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2271 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2272 if (ist->user_set_discard == AVDISCARD_ALL)
2274 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2275 score > best_score) {
2281 new_audio_stream(o, oc, idx);
2284 /* subtitles: pick first */
2285 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2286 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2287 for (i = 0; i < nb_input_streams; i++)
2288 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2289 AVCodecDescriptor const *input_descriptor =
2290 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2291 AVCodecDescriptor const *output_descriptor = NULL;
2292 AVCodec const *output_codec =
2293 avcodec_find_encoder(oc->oformat->subtitle_codec);
2294 int input_props = 0, output_props = 0;
2295 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2298 output_descriptor = avcodec_descriptor_get(output_codec->id);
2299 if (input_descriptor)
2300 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2301 if (output_descriptor)
2302 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2303 if (subtitle_codec_name ||
2304 input_props & output_props ||
2305 // Map dvb teletext which has neither property to any output subtitle encoder
2306 input_descriptor && output_descriptor &&
2307 (!input_descriptor->props ||
2308 !output_descriptor->props)) {
2309 new_subtitle_stream(o, oc, i);
2314 /* Data only if codec id match */
2315 if (!o->data_disable ) {
2316 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2317 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2318 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2320 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2321 && input_streams[i]->st->codecpar->codec_id == codec_id )
2322 new_data_stream(o, oc, i);
2326 for (i = 0; i < o->nb_stream_maps; i++) {
2327 StreamMap *map = &o->stream_maps[i];
2332 if (map->linklabel) {
2334 OutputFilter *ofilter = NULL;
2337 for (j = 0; j < nb_filtergraphs; j++) {
2338 fg = filtergraphs[j];
2339 for (k = 0; k < fg->nb_outputs; k++) {
2340 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2341 if (out && !strcmp(out->name, map->linklabel)) {
2342 ofilter = fg->outputs[k];
2349 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2350 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2353 init_output_filter(ofilter, o, oc);
2355 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2357 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2358 if (ist->user_set_discard == AVDISCARD_ALL) {
2359 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2360 map->file_index, map->stream_index);
2363 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2365 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2367 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2369 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2373 switch (ist->st->codecpar->codec_type) {
2374 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2375 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2376 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2377 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2378 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2379 case AVMEDIA_TYPE_UNKNOWN:
2380 if (copy_unknown_streams) {
2381 ost = new_unknown_stream (o, oc, src_idx);
2385 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2386 "Cannot map stream #%d:%d - unsupported type.\n",
2387 map->file_index, map->stream_index);
2388 if (!ignore_unknown_streams) {
2389 av_log(NULL, AV_LOG_FATAL,
2390 "If you want unsupported types ignored instead "
2391 "of failing, please use the -ignore_unknown option\n"
2392 "If you want them copied, please use -copy_unknown\n");
2397 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2398 + map->sync_stream_index];
2403 /* handle attached files */
2404 for (i = 0; i < o->nb_attachments; i++) {
2406 uint8_t *attachment;
2410 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2411 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2415 if ((len = avio_size(pb)) <= 0) {
2416 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2420 if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2421 !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2422 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2426 avio_read(pb, attachment, len);
2427 memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2429 ost = new_attachment_stream(o, oc, -1);
2430 ost->stream_copy = 0;
2431 ost->attachment_filename = o->attachments[i];
2432 ost->st->codecpar->extradata = attachment;
2433 ost->st->codecpar->extradata_size = len;
2435 p = strrchr(o->attachments[i], '/');
2436 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2440 #if FF_API_LAVF_AVCTX
2441 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2442 AVDictionaryEntry *e;
2443 ost = output_streams[i];
2445 if ((ost->stream_copy || ost->attachment_filename)
2446 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2447 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2448 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2453 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2454 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2455 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2459 /* check if all codec options have been used */
2460 unused_opts = strip_specifiers(o->g->codec_opts);
2461 for (i = of->ost_index; i < nb_output_streams; i++) {
2463 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2464 AV_DICT_IGNORE_SUFFIX)))
2465 av_dict_set(&unused_opts, e->key, NULL, 0);
2469 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2470 const AVClass *class = avcodec_get_class();
2471 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2472 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2473 const AVClass *fclass = avformat_get_class();
2474 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2475 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2476 if (!option || foption)
2480 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2481 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2482 "output file #%d (%s) is not an encoding option.\n", e->key,
2483 option->help ? option->help : "", nb_output_files - 1,
2488 // gop_timecode is injected by generic code but not always used
2489 if (!strcmp(e->key, "gop_timecode"))
2492 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2493 "output file #%d (%s) has not been used for any stream. The most "
2494 "likely reason is either wrong type (e.g. a video option with "
2495 "no video streams) or that it is a private option of some encoder "
2496 "which was not actually used for any stream.\n", e->key,
2497 option->help ? option->help : "", nb_output_files - 1, filename);
2499 av_dict_free(&unused_opts);
2501 /* set the decoding_needed flags and create simple filtergraphs */
2502 for (i = of->ost_index; i < nb_output_streams; i++) {
2503 OutputStream *ost = output_streams[i];
2505 if (ost->encoding_needed && ost->source_index >= 0) {
2506 InputStream *ist = input_streams[ost->source_index];
2507 ist->decoding_needed |= DECODING_FOR_OST;
2509 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2510 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2511 err = init_simple_filtergraph(ist, ost);
2513 av_log(NULL, AV_LOG_ERROR,
2514 "Error initializing a simple filtergraph between streams "
2515 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2516 nb_output_files - 1, ost->st->index);
2522 /* set the filter output constraints */
2524 OutputFilter *f = ost->filter;
2526 switch (ost->enc_ctx->codec_type) {
2527 case AVMEDIA_TYPE_VIDEO:
2528 f->frame_rate = ost->frame_rate;
2529 f->width = ost->enc_ctx->width;
2530 f->height = ost->enc_ctx->height;
2531 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2532 f->format = ost->enc_ctx->pix_fmt;
2533 } else if (ost->enc->pix_fmts) {
2535 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2537 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2540 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2543 case AVMEDIA_TYPE_AUDIO:
2544 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2545 f->format = ost->enc_ctx->sample_fmt;
2546 } else if (ost->enc->sample_fmts) {
2548 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2550 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2553 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2555 if (ost->enc_ctx->sample_rate) {
2556 f->sample_rate = ost->enc_ctx->sample_rate;
2557 } else if (ost->enc->supported_samplerates) {
2559 while (ost->enc->supported_samplerates[count])
2561 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2562 if (!f->sample_rates)
2564 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2565 (count + 1) * sizeof(*f->sample_rates));
2567 if (ost->enc_ctx->channels) {
2568 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2569 } else if (ost->enc->channel_layouts) {
2571 while (ost->enc->channel_layouts[count])
2573 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2574 if (!f->channel_layouts)
2576 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2577 (count + 1) * sizeof(*f->channel_layouts));
2584 /* check filename in case of an image number is expected */
2585 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2586 if (!av_filename_number_test(oc->url)) {
2587 print_error(oc->url, AVERROR(EINVAL));
2592 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2593 av_log(NULL, AV_LOG_ERROR,
2594 "No input streams but output needs an input stream\n");
2598 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2599 /* test if it already exists to avoid losing precious files */
2600 assert_file_overwrite(filename);
2603 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2604 &oc->interrupt_callback,
2606 print_error(filename, err);
2609 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2610 assert_file_overwrite(filename);
2612 if (o->mux_preload) {
2613 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2615 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2618 for (i = 0; i < o->nb_metadata_map; i++) {
2620 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2622 if (in_file_index >= nb_input_files) {
2623 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2626 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2627 in_file_index >= 0 ?
2628 input_files[in_file_index]->ctx : NULL, o);
2632 if (o->chapters_input_file >= nb_input_files) {
2633 if (o->chapters_input_file == INT_MAX) {
2634 /* copy chapters from the first input file that has them*/
2635 o->chapters_input_file = -1;
2636 for (i = 0; i < nb_input_files; i++)
2637 if (input_files[i]->ctx->nb_chapters) {
2638 o->chapters_input_file = i;
2642 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2643 o->chapters_input_file);
2647 if (o->chapters_input_file >= 0)
2648 copy_chapters(input_files[o->chapters_input_file], of,
2649 !o->metadata_chapters_manual);
2651 /* copy global metadata by default */
2652 if (!o->metadata_global_manual && nb_input_files){
2653 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2654 AV_DICT_DONT_OVERWRITE);
2655 if(o->recording_time != INT64_MAX)
2656 av_dict_set(&oc->metadata, "duration", NULL, 0);
2657 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2658 av_dict_set(&oc->metadata, "company_name", NULL, 0);
2659 av_dict_set(&oc->metadata, "product_name", NULL, 0);
2660 av_dict_set(&oc->metadata, "product_version", NULL, 0);
2662 if (!o->metadata_streams_manual)
2663 for (i = of->ost_index; i < nb_output_streams; i++) {
2665 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2667 ist = input_streams[output_streams[i]->source_index];
2668 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2669 if (!output_streams[i]->stream_copy) {
2670 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2674 /* process manually set programs */
2675 for (i = 0; i < o->nb_program; i++) {
2676 const char *p = o->program[i].u.str;
2681 const char *p2 = av_get_token(&p, ":");
2682 const char *to_dealloc = p2;
2689 key = av_get_token(&p2, "=");
2691 av_freep(&to_dealloc);
2697 if (!strcmp(key, "program_num"))
2698 progid = strtol(p2, NULL, 0);
2699 av_freep(&to_dealloc);
2703 program = av_new_program(oc, progid);
2705 p = o->program[i].u.str;
2707 const char *p2 = av_get_token(&p, ":");
2708 const char *to_dealloc = p2;
2714 key = av_get_token(&p2, "=");
2716 av_log(NULL, AV_LOG_FATAL,
2717 "No '=' character in program string %s.\n",
2725 if (!strcmp(key, "title")) {
2726 av_dict_set(&program->metadata, "title", p2, 0);
2727 } else if (!strcmp(key, "program_num")) {
2728 } else if (!strcmp(key, "st")) {
2729 int st_num = strtol(p2, NULL, 0);
2730 av_program_add_stream_index(oc, progid, st_num);
2732 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2735 av_freep(&to_dealloc);
2740 /* process manually set metadata */
2741 for (i = 0; i < o->nb_metadata; i++) {
2744 const char *stream_spec;
2745 int index = 0, j, ret = 0;
2747 val = strchr(o->metadata[i].u.str, '=');
2749 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2750 o->metadata[i].u.str);
2755 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2757 for (j = 0; j < oc->nb_streams; j++) {
2758 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2759 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2760 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2762 double theta = av_strtod(val, &tail);
2764 ost->rotate_overridden = 1;
2765 ost->rotate_override_value = theta;
2768 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2780 if (index < 0 || index >= oc->nb_chapters) {
2781 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2784 m = &oc->chapters[index]->metadata;
2787 if (index < 0 || index >= oc->nb_programs) {
2788 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2791 m = &oc->programs[index]->metadata;
2794 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2797 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2804 static int opt_target(void *optctx, const char *opt, const char *arg)
2806 OptionsContext *o = optctx;
2807 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2808 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2810 if (!strncmp(arg, "pal-", 4)) {
2813 } else if (!strncmp(arg, "ntsc-", 5)) {
2816 } else if (!strncmp(arg, "film-", 5)) {
2820 /* Try to determine PAL/NTSC by peeking in the input files */
2821 if (nb_input_files) {
2823 for (j = 0; j < nb_input_files; j++) {
2824 for (i = 0; i < input_files[j]->nb_streams; i++) {
2825 AVStream *st = input_files[j]->ctx->streams[i];
2827 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2829 fr = st->time_base.den * 1000LL / st->time_base.num;
2833 } else if ((fr == 29970) || (fr == 23976)) {
2838 if (norm != UNKNOWN)
2842 if (norm != UNKNOWN)
2843 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2846 if (norm == UNKNOWN) {
2847 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2848 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2849 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2853 if (!strcmp(arg, "vcd")) {
2854 opt_video_codec(o, "c:v", "mpeg1video");
2855 opt_audio_codec(o, "c:a", "mp2");
2856 parse_option(o, "f", "vcd", options);
2858 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2859 parse_option(o, "r", frame_rates[norm], options);
2860 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2862 opt_default(NULL, "b:v", "1150000");
2863 opt_default(NULL, "maxrate:v", "1150000");
2864 opt_default(NULL, "minrate:v", "1150000");
2865 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2867 opt_default(NULL, "b:a", "224000");
2868 parse_option(o, "ar", "44100", options);
2869 parse_option(o, "ac", "2", options);
2871 opt_default(NULL, "packetsize", "2324");
2872 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2874 /* We have to offset the PTS, so that it is consistent with the SCR.
2875 SCR starts at 36000, but the first two packs contain only padding
2876 and the first pack from the other stream, respectively, may also have
2877 been written before.
2878 So the real data starts at SCR 36000+3*1200. */
2879 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2880 } else if (!strcmp(arg, "svcd")) {
2882 opt_video_codec(o, "c:v", "mpeg2video");
2883 opt_audio_codec(o, "c:a", "mp2");
2884 parse_option(o, "f", "svcd", options);
2886 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2887 parse_option(o, "r", frame_rates[norm], options);
2888 parse_option(o, "pix_fmt", "yuv420p", options);
2889 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2891 opt_default(NULL, "b:v", "2040000");
2892 opt_default(NULL, "maxrate:v", "2516000");
2893 opt_default(NULL, "minrate:v", "0"); // 1145000;
2894 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2895 opt_default(NULL, "scan_offset", "1");
2897 opt_default(NULL, "b:a", "224000");
2898 parse_option(o, "ar", "44100", options);
2900 opt_default(NULL, "packetsize", "2324");
2902 } else if (!strcmp(arg, "dvd")) {
2904 opt_video_codec(o, "c:v", "mpeg2video");
2905 opt_audio_codec(o, "c:a", "ac3");
2906 parse_option(o, "f", "dvd", options);
2908 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2909 parse_option(o, "r", frame_rates[norm], options);
2910 parse_option(o, "pix_fmt", "yuv420p", options);
2911 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2913 opt_default(NULL, "b:v", "6000000");
2914 opt_default(NULL, "maxrate:v", "9000000");
2915 opt_default(NULL, "minrate:v", "0"); // 1500000;
2916 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2918 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2919 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2921 opt_default(NULL, "b:a", "448000");
2922 parse_option(o, "ar", "48000", options);
2924 } else if (!strncmp(arg, "dv", 2)) {
2926 parse_option(o, "f", "dv", options);
2928 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2929 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2930 norm == PAL ? "yuv420p" : "yuv411p", options);
2931 parse_option(o, "r", frame_rates[norm], options);
2933 parse_option(o, "ar", "48000", options);
2934 parse_option(o, "ac", "2", options);
2937 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2938 return AVERROR(EINVAL);
2941 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2942 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2947 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2949 av_free (vstats_filename);
2950 vstats_filename = av_strdup (arg);
2954 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2957 time_t today2 = time(NULL);
2958 struct tm *today = localtime(&today2);
2960 if (!today) { // maybe tomorrow
2961 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2965 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2967 return opt_vstats_file(NULL, opt, filename);
2970 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2972 OptionsContext *o = optctx;
2973 return parse_option(o, "frames:v", arg, options);
2976 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2978 OptionsContext *o = optctx;
2979 return parse_option(o, "frames:a", arg, options);
2982 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2984 OptionsContext *o = optctx;
2985 return parse_option(o, "frames:d", arg, options);
2988 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2991 AVDictionary *cbak = codec_opts;
2992 AVDictionary *fbak = format_opts;
2996 ret = opt_default(NULL, opt, arg);
2998 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2999 av_dict_copy(&o->g->format_opts, format_opts, 0);
3000 av_dict_free(&codec_opts);
3001 av_dict_free(&format_opts);
3008 static int opt_preset(void *optctx, const char *opt, const char *arg)
3010 OptionsContext *o = optctx;
3012 char filename[1000], line[1000], tmp_line[1000];
3013 const char *codec_name = NULL;
3017 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3019 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3020 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3021 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3023 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3027 while (fgets(line, sizeof(line), f)) {
3028 char *key = tmp_line, *value, *endptr;
3030 if (strcspn(line, "#\n\r") == 0)
3032 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3033 if (!av_strtok(key, "=", &value) ||
3034 !av_strtok(value, "\r\n", &endptr)) {
3035 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3038 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3040 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3041 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3042 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3043 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3044 else if (opt_default_new(o, key, value) < 0) {
3045 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3046 filename, line, key, value);
3056 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3058 OptionsContext *o = optctx;
3060 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3062 return AVERROR(ENOMEM);
3063 ret = parse_option(o, s, arg, options);
3068 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3072 if(!strcmp(opt, "ab")){
3073 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3075 } else if(!strcmp(opt, "b")){
3076 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3077 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3080 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3084 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3086 OptionsContext *o = optctx;
3089 if(!strcmp(opt, "qscale")){
3090 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3091 return parse_option(o, "q:v", arg, options);
3093 s = av_asprintf("q%s", opt + 6);
3095 return AVERROR(ENOMEM);
3096 ret = parse_option(o, s, arg, options);
3101 static int opt_profile(void *optctx, const char *opt, const char *arg)
3103 OptionsContext *o = optctx;
3104 if(!strcmp(opt, "profile")){
3105 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3106 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3109 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3113 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3115 OptionsContext *o = optctx;
3116 return parse_option(o, "filter:v", arg, options);
3119 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3121 OptionsContext *o = optctx;
3122 return parse_option(o, "filter:a", arg, options);
3125 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3127 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3128 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3129 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3130 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3132 if (video_sync_method == VSYNC_AUTO)
3133 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3137 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3139 OptionsContext *o = optctx;
3141 char *tcr = av_asprintf("timecode=%s", arg);
3143 return AVERROR(ENOMEM);
3144 ret = parse_option(o, "metadata:g", tcr, options);
3146 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3151 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3153 OptionsContext *o = optctx;
3154 char layout_str[32];
3157 int ret, channels, ac_str_size;
3160 layout = av_get_channel_layout(arg);
3162 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3163 return AVERROR(EINVAL);
3165 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3166 ret = opt_default_new(o, opt, layout_str);
3170 /* set 'ac' option based on channel layout */
3171 channels = av_get_channel_layout_nb_channels(layout);
3172 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3173 stream_str = strchr(opt, ':');
3174 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3175 ac_str = av_mallocz(ac_str_size);
3177 return AVERROR(ENOMEM);
3178 av_strlcpy(ac_str, "ac", 3);
3180 av_strlcat(ac_str, stream_str, ac_str_size);
3181 ret = parse_option(o, ac_str, layout_str, options);
3187 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3189 OptionsContext *o = optctx;
3190 return parse_option(o, "q:a", arg, options);
3193 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3195 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3196 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3197 return AVERROR(ENOMEM);
3198 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3199 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3200 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3201 return AVERROR(ENOMEM);
3203 input_stream_potentially_available = 1;
3208 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3210 uint8_t *graph_desc = read_file(arg);
3212 return AVERROR(EINVAL);
3214 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3215 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3216 return AVERROR(ENOMEM);
3217 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3218 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3220 input_stream_potentially_available = 1;
3225 void show_help_default(const char *opt, const char *arg)
3227 /* per-file options have at least one of those set */
3228 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3229 int show_advanced = 0, show_avoptions = 0;
3232 if (!strcmp(opt, "long"))
3234 else if (!strcmp(opt, "full"))
3235 show_advanced = show_avoptions = 1;
3237 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3242 printf("Getting help:\n"
3243 " -h -- print basic options\n"
3244 " -h long -- print more options\n"
3245 " -h full -- print all options (including all format and codec specific options, very long)\n"
3246 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3247 " See man %s for detailed description of the options.\n"
3248 "\n", program_name);
3250 show_help_options(options, "Print help / information / capabilities:",
3253 show_help_options(options, "Global options (affect whole program "
3254 "instead of just one file):",
3255 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3257 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3258 per_file | OPT_EXIT, 0);
3260 show_help_options(options, "Per-file main options:", 0,
3261 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3262 OPT_EXIT, per_file);
3264 show_help_options(options, "Advanced per-file options:",
3265 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3267 show_help_options(options, "Video options:",
3268 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3270 show_help_options(options, "Advanced Video options:",
3271 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3273 show_help_options(options, "Audio options:",
3274 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3276 show_help_options(options, "Advanced Audio options:",
3277 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3278 show_help_options(options, "Subtitle options:",
3279 OPT_SUBTITLE, 0, 0);
3282 if (show_avoptions) {
3283 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3284 show_help_children(avcodec_get_class(), flags);
3285 show_help_children(avformat_get_class(), flags);
3287 show_help_children(sws_get_class(), flags);
3289 #if CONFIG_SWRESAMPLE
3290 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3292 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3293 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3297 void show_usage(void)
3299 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3300 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3301 av_log(NULL, AV_LOG_INFO, "\n");
3309 static const OptionGroupDef groups[] = {
3310 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3311 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3314 static int open_files(OptionGroupList *l, const char *inout,
3315 int (*open_file)(OptionsContext*, const char*))
3319 for (i = 0; i < l->nb_groups; i++) {
3320 OptionGroup *g = &l->groups[i];
3326 ret = parse_optgroup(&o, g);
3328 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3329 "%s.\n", inout, g->arg);
3334 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3335 ret = open_file(&o, g->arg);
3338 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3342 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3348 int ffmpeg_parse_options(int argc, char **argv)
3350 OptionParseContext octx;
3354 memset(&octx, 0, sizeof(octx));
3356 /* split the commandline into an internal representation */
3357 ret = split_commandline(&octx, argc, argv, options, groups,
3358 FF_ARRAY_ELEMS(groups));
3360 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3364 /* apply global options */
3365 ret = parse_optgroup(NULL, &octx.global_opts);
3367 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3371 /* configure terminal and setup signal handlers */
3374 /* open input files */
3375 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3377 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3381 /* create the complex filtergraphs */
3382 ret = init_complex_filters();
3384 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3388 /* open output files */
3389 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3391 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3395 check_filter_outputs();
3398 uninit_parse_context(&octx);
3400 av_strerror(ret, error, sizeof(error));
3401 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3406 static int opt_progress(void *optctx, const char *opt, const char *arg)
3408 AVIOContext *avio = NULL;
3411 if (!strcmp(arg, "-"))
3413 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3415 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3416 arg, av_err2str(ret));
3419 progress_avio = avio;
3423 #define OFFSET(x) offsetof(OptionsContext, x)
3424 const OptionDef options[] = {
3426 CMDUTILS_COMMON_OPTIONS
3427 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3428 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3429 "force format", "fmt" },
3430 { "y", OPT_BOOL, { &file_overwrite },
3431 "overwrite output files" },
3432 { "n", OPT_BOOL, { &no_file_overwrite },
3433 "never overwrite output files" },
3434 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3435 "Ignore unknown stream types" },
3436 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3437 "Copy unknown stream types" },
3438 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3439 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3440 "codec name", "codec" },
3441 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3442 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3443 "codec name", "codec" },
3444 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3445 OPT_OUTPUT, { .off = OFFSET(presets) },
3446 "preset name", "preset" },
3447 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3448 OPT_OUTPUT, { .func_arg = opt_map },
3449 "set input stream mapping",
3450 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3451 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3452 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3453 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3454 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3455 "set metadata information of outfile from infile",
3456 "outfile[,metadata]:infile[,metadata]" },
3457 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3458 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3459 "set chapters mapping", "input_file_index" },
3460 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3461 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3462 "record or transcode \"duration\" seconds of audio/video",
3464 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3465 "record or transcode stop time", "time_stop" },
3466 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3467 "set the limit file size in bytes", "limit_size" },
3468 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3469 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3470 "set the start time offset", "time_off" },
3471 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3472 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3473 "set the start time offset relative to EOF", "time_off" },
3474 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3475 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3476 "enable/disable seeking by timestamp with -ss" },
3477 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3478 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3479 "enable/disable accurate seeking with -ss" },
3480 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3481 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3482 "set the input ts offset", "time_off" },
3483 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3484 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3485 "set the input ts scale", "scale" },
3486 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3487 "set the recording timestamp ('now' to set the current time)", "time" },
3488 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3489 "add metadata", "string=string" },
3490 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3491 "add program with specified streams", "title=string:st=number..." },
3492 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3493 OPT_OUTPUT, { .func_arg = opt_data_frames },
3494 "set the number of data frames to output", "number" },
3495 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3496 "add timings for benchmarking" },
3497 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3498 "add timings for each task" },
3499 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3500 "write program-readable progress information", "url" },
3501 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3502 "enable or disable interaction on standard input" },
3503 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3504 "set max runtime in seconds in CPU user time", "limit" },
3505 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3506 "dump each input packet" },
3507 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3508 "when dumping packets, also dump the payload" },
3509 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3510 OPT_INPUT, { .off = OFFSET(rate_emu) },
3511 "read input at native frame rate", "" },
3512 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3513 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3514 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3515 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3516 "video sync method", "" },
3517 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3518 "frame drop threshold", "" },
3519 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3520 "audio sync method", "" },
3521 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3522 "audio drift threshold", "threshold" },
3523 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3524 "copy timestamps" },
3525 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3526 "shift input timestamps to start at 0 when using copyts" },
3527 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3528 "copy input stream time base when stream copying", "mode" },
3529 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3530 OPT_OUTPUT, { .off = OFFSET(shortest) },
3531 "finish encoding within shortest input" },
3532 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3533 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3535 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3536 OPT_OUTPUT, { .off = OFFSET(apad) },
3538 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3539 "timestamp discontinuity delta threshold", "threshold" },
3540 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3541 "timestamp error delta threshold", "threshold" },
3542 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3543 "exit on error", "error" },
3544 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3545 "abort on the specified condition flags", "flags" },
3546 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3547 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3548 "copy initial non-keyframes" },
3549 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3550 "copy or discard frames before start time" },
3551 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3552 "set the number of frames to output", "number" },
3553 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3554 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3555 "force codec tag/fourcc", "fourcc/tag" },
3556 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3557 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3558 "use fixed quality scale (VBR)", "q" },
3559 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3560 OPT_OUTPUT, { .func_arg = opt_qscale },
3561 "use fixed quality scale (VBR)", "q" },
3562 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3563 "set profile", "profile" },
3564 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3565 "set stream filtergraph", "filter_graph" },
3566 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3567 "number of non-complex filter threads" },
3568 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3569 "read stream filtergraph description from a file", "filename" },
3570 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3571 "reinit filtergraph on input parameter changes", "" },
3572 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3573 "create a complex filtergraph", "graph_description" },
3574 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3575 "number of threads for -filter_complex" },
3576 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3577 "create a complex filtergraph", "graph_description" },
3578 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3579 "read complex filtergraph description from a file", "filename" },
3580 { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3581 "enable automatic conversion filters globally" },
3582 { "stats", OPT_BOOL, { &print_stats },
3583 "print progress report during encoding", },
3584 { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
3585 "set the period at which ffmpeg updates stats and -progress output", "time" },
3586 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3587 OPT_OUTPUT, { .func_arg = opt_attach },
3588 "add an attachment to the output file", "filename" },
3589 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3590 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3591 "extract an attachment into a file", "filename" },
3592 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3593 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3594 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3595 "print timestamp debugging info" },
3596 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3597 "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3598 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3599 OPT_INPUT, { .off = OFFSET(discard) },
3601 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3602 OPT_OUTPUT, { .off = OFFSET(disposition) },
3603 "disposition", "" },
3604 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3605 { .off = OFFSET(thread_queue_size) },
3606 "set the maximum number of queued packets from the demuxer" },
3607 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3608 "read and decode the streams to fill missing information with heuristics" },
3611 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3612 "set the number of video frames to output", "number" },
3613 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3614 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3615 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3616 { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3617 OPT_OUTPUT, { .off = OFFSET(max_frame_rates) },
3618 "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3619 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3620 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3621 "set frame size (WxH or abbreviation)", "size" },
3622 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3623 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3624 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3625 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3626 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3627 "set pixel format", "format" },
3628 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3629 "set the number of bits per raw sample", "number" },
3630 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3631 "deprecated use -g 1" },
3632 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3634 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3635 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3636 "rate control override for specific intervals", "override" },
3637 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3638 OPT_OUTPUT, { .func_arg = opt_video_codec },
3639 "force video codec ('copy' to copy stream)", "codec" },
3640 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3642 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3644 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3645 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3646 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3647 "select the pass number (1 to 3)", "n" },
3648 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3649 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3650 "select two pass log file name prefix", "prefix" },
3651 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3652 "this option is deprecated, use the yadif filter instead" },
3653 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3654 "calculate PSNR of compressed frames" },
3655 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3656 "dump video coding statistics to file" },
3657 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3658 "dump video coding statistics to file", "file" },
3659 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3660 "Version of the vstats format to use."},
3661 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3662 "set video filters", "filter_graph" },
3663 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3664 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3665 "specify intra matrix coeffs", "matrix" },
3666 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3667 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3668 "specify inter matrix coeffs", "matrix" },
3669 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3670 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3671 "specify intra matrix coeffs", "matrix" },
3672 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3673 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3674 "top=1/bottom=0/auto=-1 field first", "" },
3675 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3676 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3677 "force video tag/fourcc", "fourcc/tag" },
3678 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3679 "show QP histogram" },
3680 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3681 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3682 "force the selected framerate, disable the best supported framerate selection" },
3683 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3684 OPT_OUTPUT, { .func_arg = opt_streamid },
3685 "set the value of an outfile streamid", "streamIndex:value" },
3686 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3687 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3688 "force key frames at specified timestamps", "timestamps" },
3689 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3690 "audio bitrate (please use -b:a)", "bitrate" },
3691 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3692 "video bitrate (please use -b:v)", "bitrate" },
3693 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3694 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3695 "use HW accelerated decoding", "hwaccel name" },
3696 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3697 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3698 "select a device for HW acceleration", "devicename" },
3699 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3700 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3701 "select output format used with HW accelerated decoding", "format" },
3702 #if CONFIG_VIDEOTOOLBOX
3703 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3705 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3706 "show available HW acceleration methods" },
3707 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3708 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3709 "automatically insert correct rotate filters" },
3710 { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3711 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3712 "automatically insert a scale filter at the end of the filter graph" },
3715 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3716 "set the number of audio frames to output", "number" },
3717 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3718 "set audio quality (codec-specific)", "quality", },
3719 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3720 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3721 "set audio sampling rate (in Hz)", "rate" },
3722 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3723 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3724 "set number of audio channels", "channels" },
3725 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3727 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3728 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3729 "force audio codec ('copy' to copy stream)", "codec" },
3730 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3731 OPT_OUTPUT, { .func_arg = opt_old2new },
3732 "force audio tag/fourcc", "fourcc/tag" },
3733 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3734 "change audio volume (256=normal)" , "volume" },
3735 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3736 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3737 "set sample format", "format" },
3738 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3739 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3740 "set channel layout", "layout" },
3741 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3742 "set audio filters", "filter_graph" },
3743 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3744 "set the maximum number of channels to try to guess the channel layout" },
3746 /* subtitle options */
3747 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3748 "disable subtitle" },
3749 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3750 "force subtitle codec ('copy' to copy stream)", "codec" },
3751 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3752 , "force subtitle tag/fourcc", "fourcc/tag" },
3753 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3754 "fix subtitles duration" },
3755 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3756 "set canvas size (WxH or abbreviation)", "size" },
3759 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3760 "deprecated, use -channel", "channel" },
3761 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3762 "deprecated, use -standard", "standard" },
3763 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3766 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3767 "set the maximum demux-decode delay", "seconds" },
3768 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3769 "set the initial demux-decode delay", "seconds" },
3770 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3771 "specify a file in which to print sdp information", "file" },
3773 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3774 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3775 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3776 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3777 "two special values are defined - "
3778 "0 = use frame rate (video) or sample rate (audio),"
3779 "-1 = match source time base", "ratio" },
3781 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3782 "A comma-separated list of bitstream filters", "bitstream_filters" },
3783 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3784 "deprecated", "audio bitstream_filters" },
3785 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3786 "deprecated", "video bitstream_filters" },
3788 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3789 "set the audio options to the indicated preset", "preset" },
3790 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3791 "set the video options to the indicated preset", "preset" },
3792 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3793 "set the subtitle options to the indicated preset", "preset" },
3794 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3795 "set options from indicated preset file", "filename" },
3797 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3798 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3799 { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3800 "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3802 /* data codec support */
3803 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3804 "force data codec ('copy' to copy stream)", "codec" },
3805 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3809 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3810 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3814 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3815 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3818 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3819 "initialise hardware device", "args" },
3820 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3821 "set hardware device used when filtering", "device" },