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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
50 for (i = 0; i < o->nb_ ## name; i++) {\
51 char *spec = o->name[i].specifier;\
52 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53 outvar = o->name[i].u.type;\
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
62 for (i = 0; i < o->nb_ ## name; i++) {\
63 char *spec = o->name[i].specifier;\
64 if (!strcmp(spec, mediatype))\
65 outvar = o->name[i].u.type;\
69 const HWAccel hwaccels[] = {
70 #if CONFIG_VIDEOTOOLBOX
71 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
74 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
77 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
81 AVBufferRef *hw_device_ctx;
82 HWDevice *filter_hw_device;
84 char *vstats_filename;
87 float audio_drift_threshold = 0.1;
88 float dts_delta_threshold = 10;
89 float dts_error_threshold = 3600*30;
91 int audio_volume = 256;
92 int audio_sync_method = 0;
93 int video_sync_method = VSYNC_AUTO;
94 float frame_drop_threshold = 0;
95 int do_deinterlace = 0;
97 int do_benchmark_all = 0;
101 int start_at_zero = 0;
104 int exit_on_error = 0;
105 int abort_on_flags = 0;
106 int print_stats = -1;
108 int stdin_interaction = 1;
109 int frame_bits_per_raw_sample = 0;
110 float max_error_rate = 2.0/3;
111 int filter_nbthreads = 0;
112 int filter_complex_nbthreads = 0;
113 int vstats_version = 2;
116 static int intra_only = 0;
117 static int file_overwrite = 0;
118 static int no_file_overwrite = 0;
119 static int do_psnr = 0;
120 static int input_sync;
121 static int input_stream_potentially_available = 0;
122 static int ignore_unknown_streams = 0;
123 static int copy_unknown_streams = 0;
124 static int find_stream_info = 1;
126 static void uninit_options(OptionsContext *o)
128 const OptionDef *po = options;
131 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
133 void *dst = (uint8_t*)o + po->u.off;
135 if (po->flags & OPT_SPEC) {
136 SpecifierOpt **so = dst;
137 int i, *count = (int*)(so + 1);
138 for (i = 0; i < *count; i++) {
139 av_freep(&(*so)[i].specifier);
140 if (po->flags & OPT_STRING)
141 av_freep(&(*so)[i].u.str);
145 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
150 for (i = 0; i < o->nb_stream_maps; i++)
151 av_freep(&o->stream_maps[i].linklabel);
152 av_freep(&o->stream_maps);
153 av_freep(&o->audio_channel_maps);
154 av_freep(&o->streamid_map);
155 av_freep(&o->attachments);
158 static void init_options(OptionsContext *o)
160 memset(o, 0, sizeof(*o));
162 o->stop_time = INT64_MAX;
163 o->mux_max_delay = 0.7;
164 o->start_time = AV_NOPTS_VALUE;
165 o->start_time_eof = AV_NOPTS_VALUE;
166 o->recording_time = INT64_MAX;
167 o->limit_filesize = UINT64_MAX;
168 o->chapters_input_file = INT_MAX;
169 o->accurate_seek = 1;
172 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
174 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
177 printf("Hardware acceleration methods:\n");
178 while ((type = av_hwdevice_iterate_types(type)) !=
179 AV_HWDEVICE_TYPE_NONE)
180 printf("%s\n", av_hwdevice_get_type_name(type));
181 for (i = 0; hwaccels[i].name; i++)
182 printf("%s\n", hwaccels[i].name);
187 /* return a copy of the input with the stream specifiers removed from the keys */
188 static AVDictionary *strip_specifiers(AVDictionary *dict)
190 AVDictionaryEntry *e = NULL;
191 AVDictionary *ret = NULL;
193 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
194 char *p = strchr(e->key, ':');
198 av_dict_set(&ret, e->key, e->value, 0);
205 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
207 static const AVOption opts[] = {
208 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
209 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
212 static const AVClass class = {
214 .item_name = av_default_item_name,
216 .version = LIBAVUTIL_VERSION_INT,
218 const AVClass *pclass = &class;
220 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
223 static int opt_sameq(void *optctx, const char *opt, const char *arg)
225 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
226 "If you are looking for an option to preserve the quality (which is not "
227 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
229 return AVERROR(EINVAL);
232 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
234 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
235 return opt_default(optctx, "channel", arg);
238 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
240 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
241 return opt_default(optctx, "standard", arg);
244 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
246 OptionsContext *o = optctx;
247 return parse_option(o, "codec:a", arg, options);
250 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
252 OptionsContext *o = optctx;
253 return parse_option(o, "codec:v", arg, options);
256 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
258 OptionsContext *o = optctx;
259 return parse_option(o, "codec:s", arg, options);
262 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
264 OptionsContext *o = optctx;
265 return parse_option(o, "codec:d", arg, options);
268 static int opt_map(void *optctx, const char *opt, const char *arg)
270 OptionsContext *o = optctx;
272 int i, negative = 0, file_idx, disabled = 0;
273 int sync_file_idx = -1, sync_stream_idx = 0;
282 map = av_strdup(arg);
284 return AVERROR(ENOMEM);
286 /* parse sync stream first, just pick first matching stream */
287 if (sync = strchr(map, ',')) {
289 sync_file_idx = strtol(sync + 1, &sync, 0);
290 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
291 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
296 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
297 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
298 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
302 if (i == input_files[sync_file_idx]->nb_streams) {
303 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
304 "match any streams.\n", arg);
307 if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
308 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
316 /* this mapping refers to lavfi output */
317 const char *c = map + 1;
318 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319 m = &o->stream_maps[o->nb_stream_maps - 1];
320 m->linklabel = av_get_token(&c, "]");
322 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
326 if (allow_unused = strchr(map, '?'))
328 file_idx = strtol(map, &p, 0);
329 if (file_idx >= nb_input_files || file_idx < 0) {
330 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
334 /* disable some already defined maps */
335 for (i = 0; i < o->nb_stream_maps; i++) {
336 m = &o->stream_maps[i];
337 if (file_idx == m->file_index &&
338 check_stream_specifier(input_files[m->file_index]->ctx,
339 input_files[m->file_index]->ctx->streams[m->stream_index],
340 *p == ':' ? p + 1 : p) > 0)
344 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346 *p == ':' ? p + 1 : p) <= 0)
348 if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
352 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
353 m = &o->stream_maps[o->nb_stream_maps - 1];
355 m->file_index = file_idx;
358 if (sync_file_idx >= 0) {
359 m->sync_file_index = sync_file_idx;
360 m->sync_stream_index = sync_stream_idx;
362 m->sync_file_index = file_idx;
363 m->sync_stream_index = i;
370 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371 } else if (disabled) {
372 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
373 "To ignore this, add a trailing '?' to the map.\n", arg);
376 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
377 "To ignore this, add a trailing '?' to the map.\n", arg);
386 static int opt_attach(void *optctx, const char *opt, const char *arg)
388 OptionsContext *o = optctx;
389 GROW_ARRAY(o->attachments, o->nb_attachments);
390 o->attachments[o->nb_attachments - 1] = arg;
394 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
396 OptionsContext *o = optctx;
402 mapchan = av_strdup(arg);
404 return AVERROR(ENOMEM);
406 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
407 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
409 /* muted channel syntax */
410 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
411 if ((n == 1 || n == 3) && m->channel_idx == -1) {
412 m->file_idx = m->stream_idx = -1;
414 m->ofile_idx = m->ostream_idx = -1;
420 n = sscanf(arg, "%d.%d.%d:%d.%d",
421 &m->file_idx, &m->stream_idx, &m->channel_idx,
422 &m->ofile_idx, &m->ostream_idx);
424 if (n != 3 && n != 5) {
425 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
426 "[file.stream.channel|-1][:syncfile:syncstream]\n");
430 if (n != 5) // only file.stream.channel specified
431 m->ofile_idx = m->ostream_idx = -1;
434 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
435 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
439 if (m->stream_idx < 0 ||
440 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
441 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
442 m->file_idx, m->stream_idx);
445 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
446 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
447 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
448 m->file_idx, m->stream_idx);
451 /* allow trailing ? to map_channel */
452 if (allow_unused = strchr(mapchan, '?'))
454 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
455 input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
457 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
458 m->file_idx, m->stream_idx, m->channel_idx);
460 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
461 "To ignore this, add a trailing '?' to the map_channel.\n",
462 m->file_idx, m->stream_idx, m->channel_idx);
471 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
473 av_free(sdp_filename);
474 sdp_filename = av_strdup(arg);
479 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
482 const char *prefix = "vaapi:";
485 tmp = av_asprintf("%s%s", prefix, arg);
487 return AVERROR(ENOMEM);
488 err = hw_device_init_from_string(tmp, &dev);
492 hw_device_ctx = av_buffer_ref(dev->device_ref);
494 return AVERROR(ENOMEM);
499 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
501 if (!strcmp(arg, "list")) {
502 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
503 printf("Supported hardware device types:\n");
504 while ((type = av_hwdevice_iterate_types(type)) !=
505 AV_HWDEVICE_TYPE_NONE)
506 printf("%s\n", av_hwdevice_get_type_name(type));
510 return hw_device_init_from_string(arg, NULL);
514 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
516 if (filter_hw_device) {
517 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
518 return AVERROR(EINVAL);
520 filter_hw_device = hw_device_get_by_name(arg);
521 if (!filter_hw_device) {
522 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
523 return AVERROR(EINVAL);
529 * Parse a metadata specifier passed as 'arg' parameter.
530 * @param arg metadata string to parse
531 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
532 * @param index for type c/p, chapter/program index is written here
533 * @param stream_spec for type s, the stream specifier is written here
535 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
543 if (*(++arg) && *arg != ':') {
544 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
547 *stream_spec = *arg == ':' ? arg + 1 : "";
552 *index = strtol(++arg, NULL, 0);
555 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
562 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
564 AVDictionary **meta_in = NULL;
565 AVDictionary **meta_out = NULL;
567 char type_in, type_out;
568 const char *istream_spec = NULL, *ostream_spec = NULL;
569 int idx_in = 0, idx_out = 0;
571 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
572 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
575 if (type_out == 'g' || !*outspec)
576 o->metadata_global_manual = 1;
577 if (type_out == 's' || !*outspec)
578 o->metadata_streams_manual = 1;
579 if (type_out == 'c' || !*outspec)
580 o->metadata_chapters_manual = 1;
584 if (type_in == 'g' || type_out == 'g')
585 o->metadata_global_manual = 1;
586 if (type_in == 's' || type_out == 's')
587 o->metadata_streams_manual = 1;
588 if (type_in == 'c' || type_out == 'c')
589 o->metadata_chapters_manual = 1;
591 /* ic is NULL when just disabling automatic mappings */
595 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
596 if ((index) < 0 || (index) >= (nb_elems)) {\
597 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
602 #define SET_DICT(type, meta, context, index)\
605 meta = &context->metadata;\
608 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
609 meta = &context->chapters[index]->metadata;\
612 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
613 meta = &context->programs[index]->metadata;\
616 break; /* handled separately below */ \
617 default: av_assert0(0);\
620 SET_DICT(type_in, meta_in, ic, idx_in);
621 SET_DICT(type_out, meta_out, oc, idx_out);
623 /* for input streams choose first matching stream */
624 if (type_in == 's') {
625 for (i = 0; i < ic->nb_streams; i++) {
626 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
627 meta_in = &ic->streams[i]->metadata;
633 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
638 if (type_out == 's') {
639 for (i = 0; i < oc->nb_streams; i++) {
640 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
641 meta_out = &oc->streams[i]->metadata;
642 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
647 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
652 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
654 OptionsContext *o = optctx;
656 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
657 struct tm time = *gmtime((time_t*)&recording_timestamp);
658 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
660 parse_option(o, "metadata", buf, options);
662 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
663 "tag instead.\n", opt);
667 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
669 const AVCodecDescriptor *desc;
670 const char *codec_string = encoder ? "encoder" : "decoder";
674 avcodec_find_encoder_by_name(name) :
675 avcodec_find_decoder_by_name(name);
677 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
678 codec = encoder ? avcodec_find_encoder(desc->id) :
679 avcodec_find_decoder(desc->id);
681 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
682 codec_string, codec->name, desc->name);
686 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
689 if (codec->type != type) {
690 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
696 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
698 char *codec_name = NULL;
700 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
702 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
703 st->codecpar->codec_id = codec->id;
706 return avcodec_find_decoder(st->codecpar->codec_id);
709 /* Add all the streams from the given input file to the global
710 * list of input streams. */
711 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
715 for (i = 0; i < ic->nb_streams; i++) {
716 AVStream *st = ic->streams[i];
717 AVCodecParameters *par = st->codecpar;
718 InputStream *ist = av_mallocz(sizeof(*ist));
719 char *framerate = NULL, *hwaccel_device = NULL;
720 const char *hwaccel = NULL;
721 char *hwaccel_output_format = NULL;
722 char *codec_tag = NULL;
724 char *discard_str = NULL;
725 const AVClass *cc = avcodec_get_class();
726 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
731 GROW_ARRAY(input_streams, nb_input_streams);
732 input_streams[nb_input_streams - 1] = ist;
735 ist->file_index = nb_input_files;
737 st->discard = AVDISCARD_ALL;
739 ist->min_pts = INT64_MAX;
740 ist->max_pts = INT64_MIN;
743 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
746 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
748 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
750 uint32_t tag = strtol(codec_tag, &next, 0);
752 tag = AV_RL32(codec_tag);
753 st->codecpar->codec_tag = tag;
756 ist->dec = choose_decoder(o, ic, st);
757 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
759 ist->reinit_filters = -1;
760 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
762 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
763 ist->user_set_discard = AVDISCARD_NONE;
765 if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
766 (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
767 (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
768 (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
769 ist->user_set_discard = AVDISCARD_ALL;
771 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
772 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
777 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
779 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
781 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
785 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
787 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
792 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
794 switch (par->codec_type) {
795 case AVMEDIA_TYPE_VIDEO:
797 ist->dec = avcodec_find_decoder(par->codec_id);
799 if (st->codec->lowres) {
800 ist->dec_ctx->lowres = st->codec->lowres;
801 ist->dec_ctx->width = st->codec->width;
802 ist->dec_ctx->height = st->codec->height;
803 ist->dec_ctx->coded_width = st->codec->coded_width;
804 ist->dec_ctx->coded_height = st->codec->coded_height;
808 // avformat_find_stream_info() doesn't set this for us anymore.
809 ist->dec_ctx->framerate = st->avg_frame_rate;
811 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
812 if (framerate && av_parse_video_rate(&ist->framerate,
814 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
819 ist->top_field_first = -1;
820 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
822 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
824 // The NVDEC hwaccels use a CUDA device, so remap the name here.
825 if (!strcmp(hwaccel, "nvdec"))
828 if (!strcmp(hwaccel, "none"))
829 ist->hwaccel_id = HWACCEL_NONE;
830 else if (!strcmp(hwaccel, "auto"))
831 ist->hwaccel_id = HWACCEL_AUTO;
833 enum AVHWDeviceType type;
835 for (i = 0; hwaccels[i].name; i++) {
836 if (!strcmp(hwaccels[i].name, hwaccel)) {
837 ist->hwaccel_id = hwaccels[i].id;
842 if (!ist->hwaccel_id) {
843 type = av_hwdevice_find_type_by_name(hwaccel);
844 if (type != AV_HWDEVICE_TYPE_NONE) {
845 ist->hwaccel_id = HWACCEL_GENERIC;
846 ist->hwaccel_device_type = type;
850 if (!ist->hwaccel_id) {
851 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
853 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
854 type = AV_HWDEVICE_TYPE_NONE;
855 while ((type = av_hwdevice_iterate_types(type)) !=
856 AV_HWDEVICE_TYPE_NONE)
857 av_log(NULL, AV_LOG_FATAL, "%s ",
858 av_hwdevice_get_type_name(type));
859 for (i = 0; hwaccels[i].name; i++)
860 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
861 av_log(NULL, AV_LOG_FATAL, "\n");
867 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
868 if (hwaccel_device) {
869 ist->hwaccel_device = av_strdup(hwaccel_device);
870 if (!ist->hwaccel_device)
874 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
875 hwaccel_output_format, ic, st);
876 if (hwaccel_output_format) {
877 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
878 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
879 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
880 "format: %s", hwaccel_output_format);
883 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
886 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
889 case AVMEDIA_TYPE_AUDIO:
890 ist->guess_layout_max = INT_MAX;
891 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
892 guess_input_channel_layout(ist);
894 case AVMEDIA_TYPE_DATA:
895 case AVMEDIA_TYPE_SUBTITLE: {
896 char *canvas_size = NULL;
898 ist->dec = avcodec_find_decoder(par->codec_id);
899 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
900 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
902 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
903 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
908 case AVMEDIA_TYPE_ATTACHMENT:
909 case AVMEDIA_TYPE_UNKNOWN:
915 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
917 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
923 static void assert_file_overwrite(const char *filename)
925 const char *proto_name = avio_find_protocol_name(filename);
927 if (file_overwrite && no_file_overwrite) {
928 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
932 if (!file_overwrite) {
933 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
934 if (stdin_interaction && !no_file_overwrite) {
935 fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
938 signal(SIGINT, SIG_DFL);
940 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
946 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
952 if (proto_name && !strcmp(proto_name, "file")) {
953 for (int i = 0; i < nb_input_files; i++) {
954 InputFile *file = input_files[i];
955 if (file->ctx->iformat->flags & AVFMT_NOFILE)
957 if (!strcmp(filename, file->ctx->url)) {
958 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
959 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
966 static void dump_attachment(AVStream *st, const char *filename)
969 AVIOContext *out = NULL;
970 AVDictionaryEntry *e;
972 if (!st->codecpar->extradata_size) {
973 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
974 nb_input_files - 1, st->index);
977 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
980 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
981 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
985 assert_file_overwrite(filename);
987 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
988 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
993 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
998 static int open_input_file(OptionsContext *o, const char *filename)
1001 AVFormatContext *ic;
1002 AVInputFormat *file_iformat = NULL;
1005 AVDictionary *unused_opts = NULL;
1006 AVDictionaryEntry *e = NULL;
1007 char * video_codec_name = NULL;
1008 char * audio_codec_name = NULL;
1009 char *subtitle_codec_name = NULL;
1010 char * data_codec_name = NULL;
1011 int scan_all_pmts_set = 0;
1013 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1014 o->stop_time = INT64_MAX;
1015 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1018 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1019 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1020 if (o->stop_time <= start_time) {
1021 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1024 o->recording_time = o->stop_time - start_time;
1029 if (!(file_iformat = av_find_input_format(o->format))) {
1030 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1035 if (!strcmp(filename, "-"))
1038 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1039 strcmp(filename, "/dev/stdin");
1041 /* get default parameters from command line */
1042 ic = avformat_alloc_context();
1044 print_error(filename, AVERROR(ENOMEM));
1047 if (o->nb_audio_sample_rate) {
1048 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1050 if (o->nb_audio_channels) {
1051 /* because we set audio_channels based on both the "ac" and
1052 * "channel_layout" options, we need to check that the specified
1053 * demuxer actually has the "channels" option before setting it */
1054 if (file_iformat && file_iformat->priv_class &&
1055 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1056 AV_OPT_SEARCH_FAKE_OBJ)) {
1057 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1060 if (o->nb_frame_rates) {
1061 /* set the format-level framerate option;
1062 * this is important for video grabbers, e.g. x11 */
1063 if (file_iformat && file_iformat->priv_class &&
1064 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1065 AV_OPT_SEARCH_FAKE_OBJ)) {
1066 av_dict_set(&o->g->format_opts, "framerate",
1067 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1070 if (o->nb_frame_sizes) {
1071 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1073 if (o->nb_frame_pix_fmts)
1074 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1076 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1077 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1078 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1079 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1081 if (video_codec_name)
1082 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1083 if (audio_codec_name)
1084 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1085 if (subtitle_codec_name)
1086 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1087 if (data_codec_name)
1088 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1090 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1091 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1092 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1093 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1095 ic->flags |= AVFMT_FLAG_NONBLOCK;
1097 ic->flags |= AVFMT_FLAG_BITEXACT;
1098 ic->interrupt_callback = int_cb;
1100 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1101 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1102 scan_all_pmts_set = 1;
1104 /* open the input file with generic avformat function */
1105 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1107 print_error(filename, err);
1108 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1109 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1112 if (scan_all_pmts_set)
1113 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1114 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1115 assert_avoptions(o->g->format_opts);
1117 /* apply forced codec ids */
1118 for (i = 0; i < ic->nb_streams; i++)
1119 choose_decoder(o, ic, ic->streams[i]);
1121 if (find_stream_info) {
1122 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1123 int orig_nb_streams = ic->nb_streams;
1125 /* If not enough info to get the stream parameters, we decode the
1126 first frames to get it. (used in mpeg case for example) */
1127 ret = avformat_find_stream_info(ic, opts);
1129 for (i = 0; i < orig_nb_streams; i++)
1130 av_dict_free(&opts[i]);
1134 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1135 if (ic->nb_streams == 0) {
1136 avformat_close_input(&ic);
1142 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1143 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1144 o->start_time_eof = AV_NOPTS_VALUE;
1147 if (o->start_time_eof != AV_NOPTS_VALUE) {
1148 if (o->start_time_eof >= 0) {
1149 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1152 if (ic->duration > 0) {
1153 o->start_time = o->start_time_eof + ic->duration;
1154 if (o->start_time < 0) {
1155 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1156 o->start_time = AV_NOPTS_VALUE;
1159 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1161 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1162 /* add the stream start time */
1163 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1164 timestamp += ic->start_time;
1166 /* if seeking requested, we execute it */
1167 if (o->start_time != AV_NOPTS_VALUE) {
1168 int64_t seek_timestamp = timestamp;
1170 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1171 int dts_heuristic = 0;
1172 for (i=0; i<ic->nb_streams; i++) {
1173 const AVCodecParameters *par = ic->streams[i]->codecpar;
1174 if (par->video_delay) {
1179 if (dts_heuristic) {
1180 seek_timestamp -= 3*AV_TIME_BASE / 23;
1183 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1185 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1186 filename, (double)timestamp / AV_TIME_BASE);
1190 /* update the current parameters so that they match the one of the input stream */
1191 add_input_streams(o, ic);
1193 /* dump the file content */
1194 av_dump_format(ic, nb_input_files, filename, 0);
1196 GROW_ARRAY(input_files, nb_input_files);
1197 f = av_mallocz(sizeof(*f));
1200 input_files[nb_input_files - 1] = f;
1203 f->ist_index = nb_input_streams - ic->nb_streams;
1204 f->start_time = o->start_time;
1205 f->recording_time = o->recording_time;
1206 f->input_ts_offset = o->input_ts_offset;
1207 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1208 f->nb_streams = ic->nb_streams;
1209 f->rate_emu = o->rate_emu;
1210 f->accurate_seek = o->accurate_seek;
1213 f->time_base = (AVRational){ 1, 1 };
1215 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1218 /* check if all codec options have been used */
1219 unused_opts = strip_specifiers(o->g->codec_opts);
1220 for (i = f->ist_index; i < nb_input_streams; i++) {
1222 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1223 AV_DICT_IGNORE_SUFFIX)))
1224 av_dict_set(&unused_opts, e->key, NULL, 0);
1228 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1229 const AVClass *class = avcodec_get_class();
1230 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1231 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1232 const AVClass *fclass = avformat_get_class();
1233 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1234 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1235 if (!option || foption)
1239 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1240 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1241 "input file #%d (%s) is not a decoding option.\n", e->key,
1242 option->help ? option->help : "", nb_input_files - 1,
1247 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1248 "input file #%d (%s) has not been used for any stream. The most "
1249 "likely reason is either wrong type (e.g. a video option with "
1250 "no video streams) or that it is a private option of some decoder "
1251 "which was not actually used for any stream.\n", e->key,
1252 option->help ? option->help : "", nb_input_files - 1, filename);
1254 av_dict_free(&unused_opts);
1256 for (i = 0; i < o->nb_dump_attachment; i++) {
1259 for (j = 0; j < ic->nb_streams; j++) {
1260 AVStream *st = ic->streams[j];
1262 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1263 dump_attachment(st, o->dump_attachment[i].u.str);
1267 input_stream_potentially_available = 1;
1272 static uint8_t *get_line(AVIOContext *s)
1278 if (avio_open_dyn_buf(&line) < 0) {
1279 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1283 while ((c = avio_r8(s)) && c != '\n')
1286 avio_close_dyn_buf(line, &buf);
1291 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1294 char filename[1000];
1295 const char *base[3] = { getenv("AVCONV_DATADIR"),
1300 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1304 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1305 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1306 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1309 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1310 i != 1 ? "" : "/.avconv", preset_name);
1311 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1317 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1319 enum AVMediaType type = ost->st->codecpar->codec_type;
1320 char *codec_name = NULL;
1322 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1323 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1325 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1326 NULL, ost->st->codecpar->codec_type);
1327 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1329 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1330 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1331 "probably disabled. Please choose an encoder manually.\n",
1332 ost->file_index, ost->index, s->oformat->name,
1333 avcodec_get_name(ost->st->codecpar->codec_id));
1334 return AVERROR_ENCODER_NOT_FOUND;
1336 } else if (!strcmp(codec_name, "copy"))
1337 ost->stream_copy = 1;
1339 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1340 ost->st->codecpar->codec_id = ost->enc->id;
1342 ost->encoding_needed = !ost->stream_copy;
1344 /* no encoding supported for other media types */
1345 ost->stream_copy = 1;
1346 ost->encoding_needed = 0;
1352 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1355 AVStream *st = avformat_new_stream(oc, NULL);
1356 int idx = oc->nb_streams - 1, ret = 0;
1357 const char *bsfs = NULL, *time_base = NULL;
1358 char *next, *codec_tag = NULL;
1363 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1367 if (oc->nb_streams - 1 < o->nb_streamid_map)
1368 st->id = o->streamid_map[oc->nb_streams - 1];
1370 GROW_ARRAY(output_streams, nb_output_streams);
1371 if (!(ost = av_mallocz(sizeof(*ost))))
1373 output_streams[nb_output_streams - 1] = ost;
1375 ost->file_index = nb_output_files - 1;
1378 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1379 st->codecpar->codec_type = type;
1381 ret = choose_encoder(o, oc, ost);
1383 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1384 "%d:%d\n", ost->file_index, ost->index);
1388 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1389 if (!ost->enc_ctx) {
1390 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1393 ost->enc_ctx->codec_type = type;
1395 ost->ref_par = avcodec_parameters_alloc();
1396 if (!ost->ref_par) {
1397 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1402 AVIOContext *s = NULL;
1403 char *buf = NULL, *arg = NULL, *preset = NULL;
1405 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1407 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1408 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1411 if (!buf[0] || buf[0] == '#') {
1415 if (!(arg = strchr(buf, '='))) {
1416 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1420 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1422 } while (!s->eof_reached);
1426 av_log(NULL, AV_LOG_FATAL,
1427 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1428 preset, ost->file_index, ost->index);
1432 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1437 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1439 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1442 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1443 q.num <= 0 || q.den <= 0) {
1444 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1450 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1453 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1455 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1458 ost->enc_timebase = q;
1461 ost->max_frames = INT64_MAX;
1462 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1463 for (i = 0; i<o->nb_max_frames; i++) {
1464 char *p = o->max_frames[i].specifier;
1465 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1466 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1471 ost->copy_prior_start = -1;
1472 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1474 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1475 while (bsfs && *bsfs) {
1476 const AVBitStreamFilter *filter;
1477 char *bsf, *bsf_options_str, *bsf_name;
1479 bsf = av_get_token(&bsfs, ",");
1482 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1486 filter = av_bsf_get_by_name(bsf_name);
1488 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1492 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1493 ost->nb_bitstream_filters + 1,
1494 sizeof(*ost->bsf_ctx));
1498 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1500 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1504 ost->nb_bitstream_filters++;
1506 if (bsf_options_str && filter->priv_class) {
1507 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1508 const char * shorthand[2] = {NULL};
1511 shorthand[0] = opt->name;
1513 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1515 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1525 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1527 uint32_t tag = strtol(codec_tag, &next, 0);
1529 tag = AV_RL32(codec_tag);
1530 ost->st->codecpar->codec_tag =
1531 ost->enc_ctx->codec_tag = tag;
1534 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1536 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1537 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1540 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1541 ost->disposition = av_strdup(ost->disposition);
1543 ost->max_muxing_queue_size = 128;
1544 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1545 ost->max_muxing_queue_size *= sizeof(AVPacket);
1547 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1548 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1550 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1552 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1553 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1554 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1556 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1558 ost->source_index = source_index;
1559 if (source_index >= 0) {
1560 ost->sync_ist = input_streams[source_index];
1561 input_streams[source_index]->discard = 0;
1562 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1564 ost->last_mux_dts = AV_NOPTS_VALUE;
1566 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1567 if (!ost->muxing_queue)
1573 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1576 const char *p = str;
1583 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1590 /* read file contents into a string */
1591 static uint8_t *read_file(const char *filename)
1593 AVIOContext *pb = NULL;
1594 AVIOContext *dyn_buf = NULL;
1595 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1596 uint8_t buf[1024], *str;
1599 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1603 ret = avio_open_dyn_buf(&dyn_buf);
1608 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1609 avio_write(dyn_buf, buf, ret);
1610 avio_w8(dyn_buf, 0);
1613 ret = avio_close_dyn_buf(dyn_buf, &str);
1619 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1622 AVStream *st = ost->st;
1624 if (ost->filters_script && ost->filters) {
1625 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1626 "output stream #%d:%d.\n", nb_output_files, st->index);
1630 if (ost->filters_script)
1631 return read_file(ost->filters_script);
1632 else if (ost->filters)
1633 return av_strdup(ost->filters);
1635 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1639 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1640 const OutputStream *ost, enum AVMediaType type)
1642 if (ost->filters_script || ost->filters) {
1643 av_log(NULL, AV_LOG_ERROR,
1644 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1645 "Filtering and streamcopy cannot be used together.\n",
1646 ost->filters ? "Filtergraph" : "Filtergraph script",
1647 ost->filters ? ost->filters : ost->filters_script,
1648 av_get_media_type_string(type), ost->file_index, ost->index);
1653 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1657 AVCodecContext *video_enc;
1658 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1660 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1662 video_enc = ost->enc_ctx;
1664 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1665 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1666 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1669 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1670 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1672 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1673 if (frame_aspect_ratio) {
1675 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1676 q.num <= 0 || q.den <= 0) {
1677 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1680 ost->frame_aspect_ratio = q;
1683 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1684 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1685 if (o->nb_filters > 1)
1686 av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);
1688 if (!ost->stream_copy) {
1689 const char *p = NULL;
1690 char *frame_size = NULL;
1691 char *frame_pix_fmt = NULL;
1692 char *intra_matrix = NULL, *inter_matrix = NULL;
1693 char *chroma_intra_matrix = NULL;
1697 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1698 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1699 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1703 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1704 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1705 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1706 ost->keep_pix_fmt = 1;
1707 if (!*++frame_pix_fmt)
1708 frame_pix_fmt = NULL;
1710 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1711 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1714 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1717 video_enc->gop_size = 0;
1718 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1720 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1721 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1724 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1726 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1727 if (chroma_intra_matrix) {
1728 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1730 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1733 video_enc->chroma_intra_matrix = p;
1734 parse_matrix_coeffs(p, chroma_intra_matrix);
1736 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1738 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1739 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1742 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1745 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1746 for (i = 0; p; i++) {
1748 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1750 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1753 video_enc->rc_override =
1754 av_realloc_array(video_enc->rc_override,
1755 i + 1, sizeof(RcOverride));
1756 if (!video_enc->rc_override) {
1757 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1760 video_enc->rc_override[i].start_frame = start;
1761 video_enc->rc_override[i].end_frame = end;
1763 video_enc->rc_override[i].qscale = q;
1764 video_enc->rc_override[i].quality_factor = 1.0;
1767 video_enc->rc_override[i].qscale = 0;
1768 video_enc->rc_override[i].quality_factor = -q/100.0;
1773 video_enc->rc_override_count = i;
1776 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1779 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1782 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1783 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1786 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1787 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1791 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1792 if (ost->logfile_prefix &&
1793 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1797 char logfilename[1024];
1800 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1801 ost->logfile_prefix ? ost->logfile_prefix :
1802 DEFAULT_PASS_LOGFILENAME_PREFIX,
1804 if (!strcmp(ost->enc->name, "libx264")) {
1805 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1807 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1808 char *logbuffer = read_file(logfilename);
1811 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1815 video_enc->stats_in = logbuffer;
1817 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1818 f = av_fopen_utf8(logfilename, "wb");
1820 av_log(NULL, AV_LOG_FATAL,
1821 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1822 logfilename, strerror(errno));
1830 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1831 if (ost->forced_keyframes)
1832 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1834 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1836 ost->top_field_first = -1;
1837 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1840 ost->avfilter = get_ost_filters(o, oc, ost);
1844 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1847 if (ost->stream_copy)
1848 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1853 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1858 AVCodecContext *audio_enc;
1860 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1863 audio_enc = ost->enc_ctx;
1864 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1866 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1867 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1868 if (o->nb_filters > 1)
1869 av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);
1871 if (!ost->stream_copy) {
1872 char *sample_fmt = NULL;
1874 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1876 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1878 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1879 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1883 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1885 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1886 ost->apad = av_strdup(ost->apad);
1888 ost->avfilter = get_ost_filters(o, oc, ost);
1892 /* check for channel mapping for this audio stream */
1893 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1894 AudioChannelMap *map = &o->audio_channel_maps[n];
1895 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1896 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1899 if (map->channel_idx == -1) {
1901 } else if (ost->source_index < 0) {
1902 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1903 ost->file_index, ost->st->index);
1906 ist = input_streams[ost->source_index];
1909 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1910 if (av_reallocp_array(&ost->audio_channels_map,
1911 ost->audio_channels_mapped + 1,
1912 sizeof(*ost->audio_channels_map)
1916 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1922 if (ost->stream_copy)
1923 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1928 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1932 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1933 if (!ost->stream_copy) {
1934 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1941 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1945 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1946 if (!ost->stream_copy) {
1947 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1954 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1956 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1957 ost->stream_copy = 1;
1962 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1966 AVCodecContext *subtitle_enc;
1968 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1970 subtitle_enc = ost->enc_ctx;
1972 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1974 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1976 if (!ost->stream_copy) {
1977 char *frame_size = NULL;
1979 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1980 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1981 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1989 /* arg format is "output-stream-index:streamid-value". */
1990 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1992 OptionsContext *o = optctx;
1997 av_strlcpy(idx_str, arg, sizeof(idx_str));
1998 p = strchr(idx_str, ':');
2000 av_log(NULL, AV_LOG_FATAL,
2001 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2006 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2007 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2008 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2012 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2014 AVFormatContext *is = ifile->ctx;
2015 AVFormatContext *os = ofile->ctx;
2019 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2021 return AVERROR(ENOMEM);
2024 for (i = 0; i < is->nb_chapters; i++) {
2025 AVChapter *in_ch = is->chapters[i], *out_ch;
2026 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2027 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2028 AV_TIME_BASE_Q, in_ch->time_base);
2029 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2030 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2033 if (in_ch->end < ts_off)
2035 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2038 out_ch = av_mallocz(sizeof(AVChapter));
2040 return AVERROR(ENOMEM);
2042 out_ch->id = in_ch->id;
2043 out_ch->time_base = in_ch->time_base;
2044 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2045 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2048 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2050 os->chapters[os->nb_chapters++] = out_ch;
2055 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2056 AVFormatContext *oc)
2060 switch (ofilter->type) {
2061 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2062 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2064 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2069 ost->source_index = -1;
2070 ost->filter = ofilter;
2073 ofilter->format = -1;
2075 if (ost->stream_copy) {
2076 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2077 "which is fed from a complex filtergraph. Filtering and streamcopy "
2078 "cannot be used together.\n", ost->file_index, ost->index);
2082 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2083 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2084 av_log(NULL, AV_LOG_ERROR,
2085 "%s '%s' was specified through the %s option "
2086 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2087 "%s and -filter_complex cannot be used together for the same stream.\n",
2088 ost->filters ? "Filtergraph" : "Filtergraph script",
2089 ost->filters ? ost->filters : ost->filters_script,
2090 opt, ost->file_index, ost->index, opt);
2094 avfilter_inout_free(&ofilter->out_tmp);
2097 static int init_complex_filters(void)
2101 for (i = 0; i < nb_filtergraphs; i++) {
2102 ret = init_complex_filtergraph(filtergraphs[i]);
2109 static int open_output_file(OptionsContext *o, const char *filename)
2111 AVFormatContext *oc;
2116 AVDictionary *unused_opts = NULL;
2117 AVDictionaryEntry *e = NULL;
2118 int format_flags = 0;
2120 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2121 o->stop_time = INT64_MAX;
2122 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2125 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2126 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2127 if (o->stop_time <= start_time) {
2128 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2131 o->recording_time = o->stop_time - start_time;
2135 GROW_ARRAY(output_files, nb_output_files);
2136 of = av_mallocz(sizeof(*of));
2139 output_files[nb_output_files - 1] = of;
2141 of->ost_index = nb_output_streams;
2142 of->recording_time = o->recording_time;
2143 of->start_time = o->start_time;
2144 of->limit_filesize = o->limit_filesize;
2145 of->shortest = o->shortest;
2146 av_dict_copy(&of->opts, o->g->format_opts, 0);
2148 if (!strcmp(filename, "-"))
2151 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2153 print_error(filename, err);
2158 if (o->recording_time != INT64_MAX)
2159 oc->duration = o->recording_time;
2161 oc->interrupt_callback = int_cb;
2163 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2165 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2166 av_opt_eval_flags(oc, o, e->value, &format_flags);
2169 format_flags |= AVFMT_FLAG_BITEXACT;
2170 oc->flags |= AVFMT_FLAG_BITEXACT;
2173 /* create streams for all unlabeled output pads */
2174 for (i = 0; i < nb_filtergraphs; i++) {
2175 FilterGraph *fg = filtergraphs[i];
2176 for (j = 0; j < fg->nb_outputs; j++) {
2177 OutputFilter *ofilter = fg->outputs[j];
2179 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2182 switch (ofilter->type) {
2183 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2184 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2185 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2187 init_output_filter(ofilter, o, oc);
2191 if (!o->nb_stream_maps) {
2192 char *subtitle_codec_name = NULL;
2193 /* pick the "best" stream of each type */
2195 /* video: highest resolution */
2196 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2197 int area = 0, idx = -1;
2198 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2199 for (i = 0; i < nb_input_streams; i++) {
2201 ist = input_streams[i];
2202 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2203 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2204 if (ist->user_set_discard == AVDISCARD_ALL)
2206 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2208 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2210 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2217 new_video_stream(o, oc, idx);
2220 /* audio: most channels */
2221 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2222 int best_score = 0, idx = -1;
2223 for (i = 0; i < nb_input_streams; i++) {
2225 ist = input_streams[i];
2226 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2227 + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2228 if (ist->user_set_discard == AVDISCARD_ALL)
2230 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2231 score > best_score) {
2237 new_audio_stream(o, oc, idx);
2240 /* subtitles: pick first */
2241 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2242 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2243 for (i = 0; i < nb_input_streams; i++)
2244 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2245 AVCodecDescriptor const *input_descriptor =
2246 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2247 AVCodecDescriptor const *output_descriptor = NULL;
2248 AVCodec const *output_codec =
2249 avcodec_find_encoder(oc->oformat->subtitle_codec);
2250 int input_props = 0, output_props = 0;
2251 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2254 output_descriptor = avcodec_descriptor_get(output_codec->id);
2255 if (input_descriptor)
2256 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2257 if (output_descriptor)
2258 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2259 if (subtitle_codec_name ||
2260 input_props & output_props ||
2261 // Map dvb teletext which has neither property to any output subtitle encoder
2262 input_descriptor && output_descriptor &&
2263 (!input_descriptor->props ||
2264 !output_descriptor->props)) {
2265 new_subtitle_stream(o, oc, i);
2270 /* Data only if codec id match */
2271 if (!o->data_disable ) {
2272 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2273 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2274 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2276 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2277 && input_streams[i]->st->codecpar->codec_id == codec_id )
2278 new_data_stream(o, oc, i);
2282 for (i = 0; i < o->nb_stream_maps; i++) {
2283 StreamMap *map = &o->stream_maps[i];
2288 if (map->linklabel) {
2290 OutputFilter *ofilter = NULL;
2293 for (j = 0; j < nb_filtergraphs; j++) {
2294 fg = filtergraphs[j];
2295 for (k = 0; k < fg->nb_outputs; k++) {
2296 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2297 if (out && !strcmp(out->name, map->linklabel)) {
2298 ofilter = fg->outputs[k];
2305 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2306 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2309 init_output_filter(ofilter, o, oc);
2311 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2313 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2314 if (ist->user_set_discard == AVDISCARD_ALL) {
2315 av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2316 map->file_index, map->stream_index);
2319 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2321 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2323 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2325 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2329 switch (ist->st->codecpar->codec_type) {
2330 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2331 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2332 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2333 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2334 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2335 case AVMEDIA_TYPE_UNKNOWN:
2336 if (copy_unknown_streams) {
2337 ost = new_unknown_stream (o, oc, src_idx);
2341 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2342 "Cannot map stream #%d:%d - unsupported type.\n",
2343 map->file_index, map->stream_index);
2344 if (!ignore_unknown_streams) {
2345 av_log(NULL, AV_LOG_FATAL,
2346 "If you want unsupported types ignored instead "
2347 "of failing, please use the -ignore_unknown option\n"
2348 "If you want them copied, please use -copy_unknown\n");
2353 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2354 + map->sync_stream_index];
2359 /* handle attached files */
2360 for (i = 0; i < o->nb_attachments; i++) {
2362 uint8_t *attachment;
2366 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2367 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2371 if ((len = avio_size(pb)) <= 0) {
2372 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2376 if (!(attachment = av_malloc(len))) {
2377 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2381 avio_read(pb, attachment, len);
2383 ost = new_attachment_stream(o, oc, -1);
2384 ost->stream_copy = 0;
2385 ost->attachment_filename = o->attachments[i];
2386 ost->st->codecpar->extradata = attachment;
2387 ost->st->codecpar->extradata_size = len;
2389 p = strrchr(o->attachments[i], '/');
2390 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2394 #if FF_API_LAVF_AVCTX
2395 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2396 AVDictionaryEntry *e;
2397 ost = output_streams[i];
2399 if ((ost->stream_copy || ost->attachment_filename)
2400 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2401 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2402 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2407 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2408 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2409 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2413 /* check if all codec options have been used */
2414 unused_opts = strip_specifiers(o->g->codec_opts);
2415 for (i = of->ost_index; i < nb_output_streams; i++) {
2417 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2418 AV_DICT_IGNORE_SUFFIX)))
2419 av_dict_set(&unused_opts, e->key, NULL, 0);
2423 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2424 const AVClass *class = avcodec_get_class();
2425 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2426 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2427 const AVClass *fclass = avformat_get_class();
2428 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2429 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2430 if (!option || foption)
2434 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2435 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2436 "output file #%d (%s) is not an encoding option.\n", e->key,
2437 option->help ? option->help : "", nb_output_files - 1,
2442 // gop_timecode is injected by generic code but not always used
2443 if (!strcmp(e->key, "gop_timecode"))
2446 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2447 "output file #%d (%s) has not been used for any stream. The most "
2448 "likely reason is either wrong type (e.g. a video option with "
2449 "no video streams) or that it is a private option of some encoder "
2450 "which was not actually used for any stream.\n", e->key,
2451 option->help ? option->help : "", nb_output_files - 1, filename);
2453 av_dict_free(&unused_opts);
2455 /* set the decoding_needed flags and create simple filtergraphs */
2456 for (i = of->ost_index; i < nb_output_streams; i++) {
2457 OutputStream *ost = output_streams[i];
2459 if (ost->encoding_needed && ost->source_index >= 0) {
2460 InputStream *ist = input_streams[ost->source_index];
2461 ist->decoding_needed |= DECODING_FOR_OST;
2463 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2464 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2465 err = init_simple_filtergraph(ist, ost);
2467 av_log(NULL, AV_LOG_ERROR,
2468 "Error initializing a simple filtergraph between streams "
2469 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2470 nb_output_files - 1, ost->st->index);
2476 /* set the filter output constraints */
2478 OutputFilter *f = ost->filter;
2480 switch (ost->enc_ctx->codec_type) {
2481 case AVMEDIA_TYPE_VIDEO:
2482 f->frame_rate = ost->frame_rate;
2483 f->width = ost->enc_ctx->width;
2484 f->height = ost->enc_ctx->height;
2485 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2486 f->format = ost->enc_ctx->pix_fmt;
2487 } else if (ost->enc->pix_fmts) {
2489 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2491 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2494 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2497 case AVMEDIA_TYPE_AUDIO:
2498 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2499 f->format = ost->enc_ctx->sample_fmt;
2500 } else if (ost->enc->sample_fmts) {
2502 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2504 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2507 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2509 if (ost->enc_ctx->sample_rate) {
2510 f->sample_rate = ost->enc_ctx->sample_rate;
2511 } else if (ost->enc->supported_samplerates) {
2513 while (ost->enc->supported_samplerates[count])
2515 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2516 if (!f->sample_rates)
2518 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2519 (count + 1) * sizeof(*f->sample_rates));
2521 if (ost->enc_ctx->channels) {
2522 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2523 } else if (ost->enc->channel_layouts) {
2525 while (ost->enc->channel_layouts[count])
2527 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2528 if (!f->channel_layouts)
2530 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2531 (count + 1) * sizeof(*f->channel_layouts));
2538 /* check filename in case of an image number is expected */
2539 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2540 if (!av_filename_number_test(oc->url)) {
2541 print_error(oc->url, AVERROR(EINVAL));
2546 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2547 av_log(NULL, AV_LOG_ERROR,
2548 "No input streams but output needs an input stream\n");
2552 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2553 /* test if it already exists to avoid losing precious files */
2554 assert_file_overwrite(filename);
2557 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2558 &oc->interrupt_callback,
2560 print_error(filename, err);
2563 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2564 assert_file_overwrite(filename);
2566 if (o->mux_preload) {
2567 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2569 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2572 for (i = 0; i < o->nb_metadata_map; i++) {
2574 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2576 if (in_file_index >= nb_input_files) {
2577 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2580 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2581 in_file_index >= 0 ?
2582 input_files[in_file_index]->ctx : NULL, o);
2586 if (o->chapters_input_file >= nb_input_files) {
2587 if (o->chapters_input_file == INT_MAX) {
2588 /* copy chapters from the first input file that has them*/
2589 o->chapters_input_file = -1;
2590 for (i = 0; i < nb_input_files; i++)
2591 if (input_files[i]->ctx->nb_chapters) {
2592 o->chapters_input_file = i;
2596 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2597 o->chapters_input_file);
2601 if (o->chapters_input_file >= 0)
2602 copy_chapters(input_files[o->chapters_input_file], of,
2603 !o->metadata_chapters_manual);
2605 /* copy global metadata by default */
2606 if (!o->metadata_global_manual && nb_input_files){
2607 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2608 AV_DICT_DONT_OVERWRITE);
2609 if(o->recording_time != INT64_MAX)
2610 av_dict_set(&oc->metadata, "duration", NULL, 0);
2611 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2613 if (!o->metadata_streams_manual)
2614 for (i = of->ost_index; i < nb_output_streams; i++) {
2616 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2618 ist = input_streams[output_streams[i]->source_index];
2619 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2620 if (!output_streams[i]->stream_copy) {
2621 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2625 /* process manually set programs */
2626 for (i = 0; i < o->nb_program; i++) {
2627 const char *p = o->program[i].u.str;
2632 const char *p2 = av_get_token(&p, ":");
2633 const char *to_dealloc = p2;
2640 key = av_get_token(&p2, "=");
2642 av_freep(&to_dealloc);
2648 if (!strcmp(key, "program_num"))
2649 progid = strtol(p2, NULL, 0);
2650 av_freep(&to_dealloc);
2654 program = av_new_program(oc, progid);
2656 p = o->program[i].u.str;
2658 const char *p2 = av_get_token(&p, ":");
2659 const char *to_dealloc = p2;
2665 key = av_get_token(&p2, "=");
2667 av_log(NULL, AV_LOG_FATAL,
2668 "No '=' character in program string %s.\n",
2676 if (!strcmp(key, "title")) {
2677 av_dict_set(&program->metadata, "title", p2, 0);
2678 } else if (!strcmp(key, "program_num")) {
2679 } else if (!strcmp(key, "st")) {
2680 int st_num = strtol(p2, NULL, 0);
2681 av_program_add_stream_index(oc, progid, st_num);
2683 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2686 av_freep(&to_dealloc);
2691 /* process manually set metadata */
2692 for (i = 0; i < o->nb_metadata; i++) {
2695 const char *stream_spec;
2696 int index = 0, j, ret = 0;
2698 val = strchr(o->metadata[i].u.str, '=');
2700 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2701 o->metadata[i].u.str);
2706 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2708 for (j = 0; j < oc->nb_streams; j++) {
2709 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2710 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2711 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2713 double theta = av_strtod(val, &tail);
2715 ost->rotate_overridden = 1;
2716 ost->rotate_override_value = theta;
2719 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2731 if (index < 0 || index >= oc->nb_chapters) {
2732 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2735 m = &oc->chapters[index]->metadata;
2738 if (index < 0 || index >= oc->nb_programs) {
2739 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2742 m = &oc->programs[index]->metadata;
2745 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2748 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2755 static int opt_target(void *optctx, const char *opt, const char *arg)
2757 OptionsContext *o = optctx;
2758 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2759 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2761 if (!strncmp(arg, "pal-", 4)) {
2764 } else if (!strncmp(arg, "ntsc-", 5)) {
2767 } else if (!strncmp(arg, "film-", 5)) {
2771 /* Try to determine PAL/NTSC by peeking in the input files */
2772 if (nb_input_files) {
2774 for (j = 0; j < nb_input_files; j++) {
2775 for (i = 0; i < input_files[j]->nb_streams; i++) {
2776 AVStream *st = input_files[j]->ctx->streams[i];
2778 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2780 fr = st->time_base.den * 1000LL / st->time_base.num;
2784 } else if ((fr == 29970) || (fr == 23976)) {
2789 if (norm != UNKNOWN)
2793 if (norm != UNKNOWN)
2794 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2797 if (norm == UNKNOWN) {
2798 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2799 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2800 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2804 if (!strcmp(arg, "vcd")) {
2805 opt_video_codec(o, "c:v", "mpeg1video");
2806 opt_audio_codec(o, "c:a", "mp2");
2807 parse_option(o, "f", "vcd", options);
2809 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2810 parse_option(o, "r", frame_rates[norm], options);
2811 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2813 opt_default(NULL, "b:v", "1150000");
2814 opt_default(NULL, "maxrate:v", "1150000");
2815 opt_default(NULL, "minrate:v", "1150000");
2816 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2818 opt_default(NULL, "b:a", "224000");
2819 parse_option(o, "ar", "44100", options);
2820 parse_option(o, "ac", "2", options);
2822 opt_default(NULL, "packetsize", "2324");
2823 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2825 /* We have to offset the PTS, so that it is consistent with the SCR.
2826 SCR starts at 36000, but the first two packs contain only padding
2827 and the first pack from the other stream, respectively, may also have
2828 been written before.
2829 So the real data starts at SCR 36000+3*1200. */
2830 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2831 } else if (!strcmp(arg, "svcd")) {
2833 opt_video_codec(o, "c:v", "mpeg2video");
2834 opt_audio_codec(o, "c:a", "mp2");
2835 parse_option(o, "f", "svcd", options);
2837 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2838 parse_option(o, "r", frame_rates[norm], options);
2839 parse_option(o, "pix_fmt", "yuv420p", options);
2840 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2842 opt_default(NULL, "b:v", "2040000");
2843 opt_default(NULL, "maxrate:v", "2516000");
2844 opt_default(NULL, "minrate:v", "0"); // 1145000;
2845 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2846 opt_default(NULL, "scan_offset", "1");
2848 opt_default(NULL, "b:a", "224000");
2849 parse_option(o, "ar", "44100", options);
2851 opt_default(NULL, "packetsize", "2324");
2853 } else if (!strcmp(arg, "dvd")) {
2855 opt_video_codec(o, "c:v", "mpeg2video");
2856 opt_audio_codec(o, "c:a", "ac3");
2857 parse_option(o, "f", "dvd", options);
2859 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2860 parse_option(o, "r", frame_rates[norm], options);
2861 parse_option(o, "pix_fmt", "yuv420p", options);
2862 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2864 opt_default(NULL, "b:v", "6000000");
2865 opt_default(NULL, "maxrate:v", "9000000");
2866 opt_default(NULL, "minrate:v", "0"); // 1500000;
2867 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2869 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2870 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2872 opt_default(NULL, "b:a", "448000");
2873 parse_option(o, "ar", "48000", options);
2875 } else if (!strncmp(arg, "dv", 2)) {
2877 parse_option(o, "f", "dv", options);
2879 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2880 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2881 norm == PAL ? "yuv420p" : "yuv411p", options);
2882 parse_option(o, "r", frame_rates[norm], options);
2884 parse_option(o, "ar", "48000", options);
2885 parse_option(o, "ac", "2", options);
2888 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2889 return AVERROR(EINVAL);
2892 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2893 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2898 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2900 av_free (vstats_filename);
2901 vstats_filename = av_strdup (arg);
2905 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2908 time_t today2 = time(NULL);
2909 struct tm *today = localtime(&today2);
2911 if (!today) { // maybe tomorrow
2912 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2916 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2918 return opt_vstats_file(NULL, opt, filename);
2921 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2923 OptionsContext *o = optctx;
2924 return parse_option(o, "frames:v", arg, options);
2927 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2929 OptionsContext *o = optctx;
2930 return parse_option(o, "frames:a", arg, options);
2933 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2935 OptionsContext *o = optctx;
2936 return parse_option(o, "frames:d", arg, options);
2939 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2942 AVDictionary *cbak = codec_opts;
2943 AVDictionary *fbak = format_opts;
2947 ret = opt_default(NULL, opt, arg);
2949 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2950 av_dict_copy(&o->g->format_opts, format_opts, 0);
2951 av_dict_free(&codec_opts);
2952 av_dict_free(&format_opts);
2959 static int opt_preset(void *optctx, const char *opt, const char *arg)
2961 OptionsContext *o = optctx;
2963 char filename[1000], line[1000], tmp_line[1000];
2964 const char *codec_name = NULL;
2968 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2970 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2971 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2972 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2974 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2978 while (fgets(line, sizeof(line), f)) {
2979 char *key = tmp_line, *value, *endptr;
2981 if (strcspn(line, "#\n\r") == 0)
2983 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2984 if (!av_strtok(key, "=", &value) ||
2985 !av_strtok(value, "\r\n", &endptr)) {
2986 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2989 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2991 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2992 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2993 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2994 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2995 else if (opt_default_new(o, key, value) < 0) {
2996 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2997 filename, line, key, value);
3007 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3009 OptionsContext *o = optctx;
3010 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3011 int ret = parse_option(o, s, arg, options);
3016 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3018 OptionsContext *o = optctx;
3020 if(!strcmp(opt, "ab")){
3021 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3023 } else if(!strcmp(opt, "b")){
3024 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3025 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3028 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3032 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3034 OptionsContext *o = optctx;
3037 if(!strcmp(opt, "qscale")){
3038 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3039 return parse_option(o, "q:v", arg, options);
3041 s = av_asprintf("q%s", opt + 6);
3042 ret = parse_option(o, s, arg, options);
3047 static int opt_profile(void *optctx, const char *opt, const char *arg)
3049 OptionsContext *o = optctx;
3050 if(!strcmp(opt, "profile")){
3051 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3052 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3055 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3059 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3061 OptionsContext *o = optctx;
3062 return parse_option(o, "filter:v", arg, options);
3065 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3067 OptionsContext *o = optctx;
3068 return parse_option(o, "filter:a", arg, options);
3071 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3073 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3074 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3075 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3076 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3078 if (video_sync_method == VSYNC_AUTO)
3079 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3083 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3085 OptionsContext *o = optctx;
3086 char *tcr = av_asprintf("timecode=%s", arg);
3087 int ret = parse_option(o, "metadata:g", tcr, options);
3089 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3094 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3096 OptionsContext *o = optctx;
3097 char layout_str[32];
3100 int ret, channels, ac_str_size;
3103 layout = av_get_channel_layout(arg);
3105 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3106 return AVERROR(EINVAL);
3108 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3109 ret = opt_default_new(o, opt, layout_str);
3113 /* set 'ac' option based on channel layout */
3114 channels = av_get_channel_layout_nb_channels(layout);
3115 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3116 stream_str = strchr(opt, ':');
3117 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3118 ac_str = av_mallocz(ac_str_size);
3120 return AVERROR(ENOMEM);
3121 av_strlcpy(ac_str, "ac", 3);
3123 av_strlcat(ac_str, stream_str, ac_str_size);
3124 ret = parse_option(o, ac_str, layout_str, options);
3130 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3132 OptionsContext *o = optctx;
3133 return parse_option(o, "q:a", arg, options);
3136 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3138 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3139 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3140 return AVERROR(ENOMEM);
3141 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3142 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3143 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3144 return AVERROR(ENOMEM);
3146 input_stream_potentially_available = 1;
3151 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3153 uint8_t *graph_desc = read_file(arg);
3155 return AVERROR(EINVAL);
3157 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3158 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3159 return AVERROR(ENOMEM);
3160 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3161 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3163 input_stream_potentially_available = 1;
3168 void show_help_default(const char *opt, const char *arg)
3170 /* per-file options have at least one of those set */
3171 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3172 int show_advanced = 0, show_avoptions = 0;
3175 if (!strcmp(opt, "long"))
3177 else if (!strcmp(opt, "full"))
3178 show_advanced = show_avoptions = 1;
3180 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3185 printf("Getting help:\n"
3186 " -h -- print basic options\n"
3187 " -h long -- print more options\n"
3188 " -h full -- print all options (including all format and codec specific options, very long)\n"
3189 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3190 " See man %s for detailed description of the options.\n"
3191 "\n", program_name);
3193 show_help_options(options, "Print help / information / capabilities:",
3196 show_help_options(options, "Global options (affect whole program "
3197 "instead of just one file:",
3198 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3200 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3201 per_file | OPT_EXIT, 0);
3203 show_help_options(options, "Per-file main options:", 0,
3204 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3205 OPT_EXIT, per_file);
3207 show_help_options(options, "Advanced per-file options:",
3208 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3210 show_help_options(options, "Video options:",
3211 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3213 show_help_options(options, "Advanced Video options:",
3214 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3216 show_help_options(options, "Audio options:",
3217 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3219 show_help_options(options, "Advanced Audio options:",
3220 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3221 show_help_options(options, "Subtitle options:",
3222 OPT_SUBTITLE, 0, 0);
3225 if (show_avoptions) {
3226 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3227 show_help_children(avcodec_get_class(), flags);
3228 show_help_children(avformat_get_class(), flags);
3230 show_help_children(sws_get_class(), flags);
3232 #if CONFIG_SWRESAMPLE
3233 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3235 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3236 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3240 void show_usage(void)
3242 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3243 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3244 av_log(NULL, AV_LOG_INFO, "\n");
3252 static const OptionGroupDef groups[] = {
3253 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3254 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3257 static int open_files(OptionGroupList *l, const char *inout,
3258 int (*open_file)(OptionsContext*, const char*))
3262 for (i = 0; i < l->nb_groups; i++) {
3263 OptionGroup *g = &l->groups[i];
3269 ret = parse_optgroup(&o, g);
3271 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3272 "%s.\n", inout, g->arg);
3276 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3277 ret = open_file(&o, g->arg);
3280 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3284 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3290 int ffmpeg_parse_options(int argc, char **argv)
3292 OptionParseContext octx;
3296 memset(&octx, 0, sizeof(octx));
3298 /* split the commandline into an internal representation */
3299 ret = split_commandline(&octx, argc, argv, options, groups,
3300 FF_ARRAY_ELEMS(groups));
3302 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3306 /* apply global options */
3307 ret = parse_optgroup(NULL, &octx.global_opts);
3309 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3313 /* configure terminal and setup signal handlers */
3316 /* open input files */
3317 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3319 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3323 /* create the complex filtergraphs */
3324 ret = init_complex_filters();
3326 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3330 /* open output files */
3331 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3333 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3337 check_filter_outputs();
3340 uninit_parse_context(&octx);
3342 av_strerror(ret, error, sizeof(error));
3343 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3348 static int opt_progress(void *optctx, const char *opt, const char *arg)
3350 AVIOContext *avio = NULL;
3353 if (!strcmp(arg, "-"))
3355 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3357 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3358 arg, av_err2str(ret));
3361 progress_avio = avio;
3365 #define OFFSET(x) offsetof(OptionsContext, x)
3366 const OptionDef options[] = {
3368 CMDUTILS_COMMON_OPTIONS
3369 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3370 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3371 "force format", "fmt" },
3372 { "y", OPT_BOOL, { &file_overwrite },
3373 "overwrite output files" },
3374 { "n", OPT_BOOL, { &no_file_overwrite },
3375 "never overwrite output files" },
3376 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3377 "Ignore unknown stream types" },
3378 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3379 "Copy unknown stream types" },
3380 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3381 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3382 "codec name", "codec" },
3383 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3384 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3385 "codec name", "codec" },
3386 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3387 OPT_OUTPUT, { .off = OFFSET(presets) },
3388 "preset name", "preset" },
3389 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3390 OPT_OUTPUT, { .func_arg = opt_map },
3391 "set input stream mapping",
3392 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3393 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3394 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3395 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3396 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3397 "set metadata information of outfile from infile",
3398 "outfile[,metadata]:infile[,metadata]" },
3399 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3400 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3401 "set chapters mapping", "input_file_index" },
3402 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3403 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3404 "record or transcode \"duration\" seconds of audio/video",
3406 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3407 "record or transcode stop time", "time_stop" },
3408 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3409 "set the limit file size in bytes", "limit_size" },
3410 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3411 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3412 "set the start time offset", "time_off" },
3413 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3414 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3415 "set the start time offset relative to EOF", "time_off" },
3416 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3417 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3418 "enable/disable seeking by timestamp with -ss" },
3419 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3420 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3421 "enable/disable accurate seeking with -ss" },
3422 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3423 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3424 "set the input ts offset", "time_off" },
3425 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3426 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3427 "set the input ts scale", "scale" },
3428 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3429 "set the recording timestamp ('now' to set the current time)", "time" },
3430 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3431 "add metadata", "string=string" },
3432 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3433 "add program with specified streams", "title=string:st=number..." },
3434 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3435 OPT_OUTPUT, { .func_arg = opt_data_frames },
3436 "set the number of data frames to output", "number" },
3437 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3438 "add timings for benchmarking" },
3439 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3440 "add timings for each task" },
3441 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3442 "write program-readable progress information", "url" },
3443 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3444 "enable or disable interaction on standard input" },
3445 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3446 "set max runtime in seconds in CPU user time", "limit" },
3447 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3448 "dump each input packet" },
3449 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3450 "when dumping packets, also dump the payload" },
3451 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3452 OPT_INPUT, { .off = OFFSET(rate_emu) },
3453 "read input at native frame rate", "" },
3454 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3455 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3456 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3457 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3458 "video sync method", "" },
3459 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3460 "frame drop threshold", "" },
3461 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3462 "audio sync method", "" },
3463 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3464 "audio drift threshold", "threshold" },
3465 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3466 "copy timestamps" },
3467 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3468 "shift input timestamps to start at 0 when using copyts" },
3469 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3470 "copy input stream time base when stream copying", "mode" },
3471 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3472 OPT_OUTPUT, { .off = OFFSET(shortest) },
3473 "finish encoding within shortest input" },
3474 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3475 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3477 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3478 OPT_OUTPUT, { .off = OFFSET(apad) },
3480 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3481 "timestamp discontinuity delta threshold", "threshold" },
3482 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3483 "timestamp error delta threshold", "threshold" },
3484 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3485 "exit on error", "error" },
3486 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3487 "abort on the specified condition flags", "flags" },
3488 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3489 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3490 "copy initial non-keyframes" },
3491 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3492 "copy or discard frames before start time" },
3493 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3494 "set the number of frames to output", "number" },
3495 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3496 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3497 "force codec tag/fourcc", "fourcc/tag" },
3498 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3499 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3500 "use fixed quality scale (VBR)", "q" },
3501 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3502 OPT_OUTPUT, { .func_arg = opt_qscale },
3503 "use fixed quality scale (VBR)", "q" },
3504 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3505 "set profile", "profile" },
3506 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3507 "set stream filtergraph", "filter_graph" },
3508 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3509 "number of non-complex filter threads" },
3510 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3511 "read stream filtergraph description from a file", "filename" },
3512 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3513 "reinit filtergraph on input parameter changes", "" },
3514 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3515 "create a complex filtergraph", "graph_description" },
3516 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3517 "number of threads for -filter_complex" },
3518 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3519 "create a complex filtergraph", "graph_description" },
3520 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3521 "read complex filtergraph description from a file", "filename" },
3522 { "stats", OPT_BOOL, { &print_stats },
3523 "print progress report during encoding", },
3524 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3525 OPT_OUTPUT, { .func_arg = opt_attach },
3526 "add an attachment to the output file", "filename" },
3527 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3528 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3529 "extract an attachment into a file", "filename" },
3530 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3531 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3532 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3533 "print timestamp debugging info" },
3534 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3535 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3536 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3537 OPT_INPUT, { .off = OFFSET(discard) },
3539 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3540 OPT_OUTPUT, { .off = OFFSET(disposition) },
3541 "disposition", "" },
3542 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3543 { .off = OFFSET(thread_queue_size) },
3544 "set the maximum number of queued packets from the demuxer" },
3545 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3546 "read and decode the streams to fill missing information with heuristics" },
3549 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3550 "set the number of video frames to output", "number" },
3551 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3552 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3553 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3554 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3555 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3556 "set frame size (WxH or abbreviation)", "size" },
3557 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3558 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3559 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3560 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3561 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3562 "set pixel format", "format" },
3563 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3564 "set the number of bits per raw sample", "number" },
3565 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3566 "deprecated use -g 1" },
3567 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3569 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3570 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3571 "rate control override for specific intervals", "override" },
3572 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3573 OPT_OUTPUT, { .func_arg = opt_video_codec },
3574 "force video codec ('copy' to copy stream)", "codec" },
3575 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3577 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3579 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3580 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3581 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3582 "select the pass number (1 to 3)", "n" },
3583 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3584 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3585 "select two pass log file name prefix", "prefix" },
3586 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3587 "this option is deprecated, use the yadif filter instead" },
3588 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3589 "calculate PSNR of compressed frames" },
3590 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3591 "dump video coding statistics to file" },
3592 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3593 "dump video coding statistics to file", "file" },
3594 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3595 "Version of the vstats format to use."},
3596 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3597 "set video filters", "filter_graph" },
3598 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3599 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3600 "specify intra matrix coeffs", "matrix" },
3601 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3602 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3603 "specify inter matrix coeffs", "matrix" },
3604 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3605 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3606 "specify intra matrix coeffs", "matrix" },
3607 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3608 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3609 "top=1/bottom=0/auto=-1 field first", "" },
3610 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3611 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3612 "force video tag/fourcc", "fourcc/tag" },
3613 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3614 "show QP histogram" },
3615 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3616 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3617 "force the selected framerate, disable the best supported framerate selection" },
3618 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3619 OPT_OUTPUT, { .func_arg = opt_streamid },
3620 "set the value of an outfile streamid", "streamIndex:value" },
3621 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3622 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3623 "force key frames at specified timestamps", "timestamps" },
3624 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3625 "audio bitrate (please use -b:a)", "bitrate" },
3626 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3627 "video bitrate (please use -b:v)", "bitrate" },
3628 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3629 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3630 "use HW accelerated decoding", "hwaccel name" },
3631 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3632 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3633 "select a device for HW acceleration", "devicename" },
3634 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3635 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3636 "select output format used with HW accelerated decoding", "format" },
3637 #if CONFIG_VIDEOTOOLBOX
3638 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3640 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3641 "show available HW acceleration methods" },
3642 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3643 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3644 "automatically insert correct rotate filters" },
3647 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3648 "set the number of audio frames to output", "number" },
3649 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3650 "set audio quality (codec-specific)", "quality", },
3651 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3652 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3653 "set audio sampling rate (in Hz)", "rate" },
3654 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3655 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3656 "set number of audio channels", "channels" },
3657 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3659 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3660 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3661 "force audio codec ('copy' to copy stream)", "codec" },
3662 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3663 OPT_OUTPUT, { .func_arg = opt_old2new },
3664 "force audio tag/fourcc", "fourcc/tag" },
3665 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3666 "change audio volume (256=normal)" , "volume" },
3667 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3668 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3669 "set sample format", "format" },
3670 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3671 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3672 "set channel layout", "layout" },
3673 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3674 "set audio filters", "filter_graph" },
3675 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3676 "set the maximum number of channels to try to guess the channel layout" },
3678 /* subtitle options */
3679 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3680 "disable subtitle" },
3681 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3682 "force subtitle codec ('copy' to copy stream)", "codec" },
3683 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3684 , "force subtitle tag/fourcc", "fourcc/tag" },
3685 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3686 "fix subtitles duration" },
3687 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3688 "set canvas size (WxH or abbreviation)", "size" },
3691 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3692 "deprecated, use -channel", "channel" },
3693 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3694 "deprecated, use -standard", "standard" },
3695 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3698 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3699 "set the maximum demux-decode delay", "seconds" },
3700 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3701 "set the initial demux-decode delay", "seconds" },
3702 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3703 "specify a file in which to print sdp information", "file" },
3705 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3706 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3707 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3708 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3709 "two special values are defined - "
3710 "0 = use frame rate (video) or sample rate (audio),"
3711 "-1 = match source time base", "ratio" },
3713 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3714 "A comma-separated list of bitstream filters", "bitstream_filters" },
3715 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3716 "deprecated", "audio bitstream_filters" },
3717 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3718 "deprecated", "video bitstream_filters" },
3720 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3721 "set the audio options to the indicated preset", "preset" },
3722 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723 "set the video options to the indicated preset", "preset" },
3724 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3725 "set the subtitle options to the indicated preset", "preset" },
3726 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3727 "set options from indicated preset file", "filename" },
3729 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3730 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3732 /* data codec support */
3733 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3734 "force data codec ('copy' to copy stream)", "codec" },
3735 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3739 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3740 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3744 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3745 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3748 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3749 "initialise hardware device", "args" },
3750 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3751 "set hardware device used when filtering", "device" },