2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
83 float dts_error_threshold = 3600*30;
85 int audio_volume = 256;
86 int audio_sync_method = 0;
87 int video_sync_method = VSYNC_AUTO;
88 int do_deinterlace = 0;
90 int do_benchmark_all = 0;
94 int start_at_zero = 0;
97 int exit_on_error = 0;
100 int stdin_interaction = 1;
101 int frame_bits_per_raw_sample = 0;
102 float max_error_rate = 2.0/3;
105 static int intra_only = 0;
106 static int file_overwrite = 0;
107 static int no_file_overwrite = 0;
108 static int do_psnr = 0;
109 static int input_sync;
110 static int override_ffserver = 0;
112 static void uninit_options(OptionsContext *o)
114 const OptionDef *po = options;
117 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
119 void *dst = (uint8_t*)o + po->u.off;
121 if (po->flags & OPT_SPEC) {
122 SpecifierOpt **so = dst;
123 int i, *count = (int*)(so + 1);
124 for (i = 0; i < *count; i++) {
125 av_freep(&(*so)[i].specifier);
126 if (po->flags & OPT_STRING)
127 av_freep(&(*so)[i].u.str);
131 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
136 for (i = 0; i < o->nb_stream_maps; i++)
137 av_freep(&o->stream_maps[i].linklabel);
138 av_freep(&o->stream_maps);
139 av_freep(&o->audio_channel_maps);
140 av_freep(&o->streamid_map);
141 av_freep(&o->attachments);
144 static void init_options(OptionsContext *o)
146 memset(o, 0, sizeof(*o));
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->start_time = AV_NOPTS_VALUE;
151 o->recording_time = INT64_MAX;
152 o->limit_filesize = UINT64_MAX;
153 o->chapters_input_file = INT_MAX;
154 o->accurate_seek = 1;
157 /* return a copy of the input with the stream specifiers removed from the keys */
158 static AVDictionary *strip_specifiers(AVDictionary *dict)
160 AVDictionaryEntry *e = NULL;
161 AVDictionary *ret = NULL;
163 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
164 char *p = strchr(e->key, ':');
168 av_dict_set(&ret, e->key, e->value, 0);
175 static int opt_sameq(void *optctx, const char *opt, const char *arg)
177 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
178 "If you are looking for an option to preserve the quality (which is not "
179 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
181 return AVERROR(EINVAL);
184 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
186 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
187 return opt_default(optctx, "channel", arg);
190 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
192 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
193 return opt_default(optctx, "standard", arg);
196 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:a", arg, options);
202 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
205 return parse_option(o, "codec:v", arg, options);
208 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
210 OptionsContext *o = optctx;
211 return parse_option(o, "codec:s", arg, options);
214 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
216 OptionsContext *o = optctx;
217 return parse_option(o, "codec:d", arg, options);
220 static int opt_map(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
224 int i, negative = 0, file_idx;
225 int sync_file_idx = -1, sync_stream_idx = 0;
233 map = av_strdup(arg);
235 /* parse sync stream first, just pick first matching stream */
236 if (sync = strchr(map, ',')) {
238 sync_file_idx = strtol(sync + 1, &sync, 0);
239 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
240 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
245 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
246 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
247 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
251 if (i == input_files[sync_file_idx]->nb_streams) {
252 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
253 "match any streams.\n", arg);
260 /* this mapping refers to lavfi output */
261 const char *c = map + 1;
262 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
263 m = &o->stream_maps[o->nb_stream_maps - 1];
264 m->linklabel = av_get_token(&c, "]");
266 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
270 file_idx = strtol(map, &p, 0);
271 if (file_idx >= nb_input_files || file_idx < 0) {
272 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
276 /* disable some already defined maps */
277 for (i = 0; i < o->nb_stream_maps; i++) {
278 m = &o->stream_maps[i];
279 if (file_idx == m->file_index &&
280 check_stream_specifier(input_files[m->file_index]->ctx,
281 input_files[m->file_index]->ctx->streams[m->stream_index],
282 *p == ':' ? p + 1 : p) > 0)
286 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
287 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
288 *p == ':' ? p + 1 : p) <= 0)
290 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
291 m = &o->stream_maps[o->nb_stream_maps - 1];
293 m->file_index = file_idx;
296 if (sync_file_idx >= 0) {
297 m->sync_file_index = sync_file_idx;
298 m->sync_stream_index = sync_stream_idx;
300 m->sync_file_index = file_idx;
301 m->sync_stream_index = i;
307 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
315 static int opt_attach(void *optctx, const char *opt, const char *arg)
317 OptionsContext *o = optctx;
318 GROW_ARRAY(o->attachments, o->nb_attachments);
319 o->attachments[o->nb_attachments - 1] = arg;
323 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
330 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
331 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
333 /* muted channel syntax */
334 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
335 if ((n == 1 || n == 3) && m->channel_idx == -1) {
336 m->file_idx = m->stream_idx = -1;
338 m->ofile_idx = m->ostream_idx = -1;
343 n = sscanf(arg, "%d.%d.%d:%d.%d",
344 &m->file_idx, &m->stream_idx, &m->channel_idx,
345 &m->ofile_idx, &m->ostream_idx);
347 if (n != 3 && n != 5) {
348 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
349 "[file.stream.channel|-1][:syncfile:syncstream]\n");
353 if (n != 5) // only file.stream.channel specified
354 m->ofile_idx = m->ostream_idx = -1;
357 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
358 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
362 if (m->stream_idx < 0 ||
363 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
364 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
365 m->file_idx, m->stream_idx);
368 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
369 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
370 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
371 m->file_idx, m->stream_idx);
374 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
375 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
376 m->file_idx, m->stream_idx, m->channel_idx);
383 * Parse a metadata specifier passed as 'arg' parameter.
384 * @param arg metadata string to parse
385 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
386 * @param index for type c/p, chapter/program index is written here
387 * @param stream_spec for type s, the stream specifier is written here
389 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
397 if (*(++arg) && *arg != ':') {
398 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
401 *stream_spec = *arg == ':' ? arg + 1 : "";
406 *index = strtol(++arg, NULL, 0);
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
416 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
418 AVDictionary **meta_in = NULL;
419 AVDictionary **meta_out = NULL;
421 char type_in, type_out;
422 const char *istream_spec = NULL, *ostream_spec = NULL;
423 int idx_in = 0, idx_out = 0;
425 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
426 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
429 if (type_out == 'g' || !*outspec)
430 o->metadata_global_manual = 1;
431 if (type_out == 's' || !*outspec)
432 o->metadata_streams_manual = 1;
433 if (type_out == 'c' || !*outspec)
434 o->metadata_chapters_manual = 1;
438 if (type_in == 'g' || type_out == 'g')
439 o->metadata_global_manual = 1;
440 if (type_in == 's' || type_out == 's')
441 o->metadata_streams_manual = 1;
442 if (type_in == 'c' || type_out == 'c')
443 o->metadata_chapters_manual = 1;
445 /* ic is NULL when just disabling automatic mappings */
449 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
450 if ((index) < 0 || (index) >= (nb_elems)) {\
451 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
456 #define SET_DICT(type, meta, context, index)\
459 meta = &context->metadata;\
462 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
463 meta = &context->chapters[index]->metadata;\
466 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
467 meta = &context->programs[index]->metadata;\
470 break; /* handled separately below */ \
471 default: av_assert0(0);\
474 SET_DICT(type_in, meta_in, ic, idx_in);
475 SET_DICT(type_out, meta_out, oc, idx_out);
477 /* for input streams choose first matching stream */
478 if (type_in == 's') {
479 for (i = 0; i < ic->nb_streams; i++) {
480 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
481 meta_in = &ic->streams[i]->metadata;
487 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
492 if (type_out == 's') {
493 for (i = 0; i < oc->nb_streams; i++) {
494 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
495 meta_out = &oc->streams[i]->metadata;
496 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
506 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
508 OptionsContext *o = optctx;
510 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
511 struct tm time = *gmtime((time_t*)&recording_timestamp);
512 if (!strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time))
514 parse_option(o, "metadata", buf, options);
516 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
517 "tag instead.\n", opt);
521 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
523 const AVCodecDescriptor *desc;
524 const char *codec_string = encoder ? "encoder" : "decoder";
528 avcodec_find_encoder_by_name(name) :
529 avcodec_find_decoder_by_name(name);
531 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
532 codec = encoder ? avcodec_find_encoder(desc->id) :
533 avcodec_find_decoder(desc->id);
535 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
536 codec_string, codec->name, desc->name);
540 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
543 if (codec->type != type) {
544 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
550 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
552 char *codec_name = NULL;
554 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
556 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
557 st->codec->codec_id = codec->id;
560 return avcodec_find_decoder(st->codec->codec_id);
563 /* Add all the streams from the given input file to the global
564 * list of input streams. */
565 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
569 for (i = 0; i < ic->nb_streams; i++) {
570 AVStream *st = ic->streams[i];
571 AVCodecContext *dec = st->codec;
572 InputStream *ist = av_mallocz(sizeof(*ist));
573 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
574 char *codec_tag = NULL;
576 char *discard_str = NULL;
577 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
582 GROW_ARRAY(input_streams, nb_input_streams);
583 input_streams[nb_input_streams - 1] = ist;
586 ist->file_index = nb_input_files;
588 st->discard = AVDISCARD_ALL;
591 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
593 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
595 uint32_t tag = strtol(codec_tag, &next, 0);
597 tag = AV_RL32(codec_tag);
598 st->codec->codec_tag = tag;
601 ist->dec = choose_decoder(o, ic, st);
602 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
604 ist->reinit_filters = -1;
605 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
607 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
608 ist->user_set_discard = AVDISCARD_NONE;
609 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
610 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
615 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
617 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
619 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
623 ret = avcodec_copy_context(ist->dec_ctx, dec);
625 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
629 switch (dec->codec_type) {
630 case AVMEDIA_TYPE_VIDEO:
632 ist->dec = avcodec_find_decoder(dec->codec_id);
633 if (av_codec_get_lowres(dec)) {
634 dec->flags |= CODEC_FLAG_EMU_EDGE;
637 ist->resample_height = ist->dec_ctx->height;
638 ist->resample_width = ist->dec_ctx->width;
639 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
641 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
642 if (framerate && av_parse_video_rate(&ist->framerate,
644 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
649 ist->top_field_first = -1;
650 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
652 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
654 if (!strcmp(hwaccel, "none"))
655 ist->hwaccel_id = HWACCEL_NONE;
656 else if (!strcmp(hwaccel, "auto"))
657 ist->hwaccel_id = HWACCEL_AUTO;
660 for (i = 0; hwaccels[i].name; i++) {
661 if (!strcmp(hwaccels[i].name, hwaccel)) {
662 ist->hwaccel_id = hwaccels[i].id;
667 if (!ist->hwaccel_id) {
668 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
670 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
671 for (i = 0; hwaccels[i].name; i++)
672 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
673 av_log(NULL, AV_LOG_FATAL, "\n");
679 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
680 if (hwaccel_device) {
681 ist->hwaccel_device = av_strdup(hwaccel_device);
682 if (!ist->hwaccel_device)
685 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
688 case AVMEDIA_TYPE_AUDIO:
689 ist->guess_layout_max = INT_MAX;
690 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
691 guess_input_channel_layout(ist);
693 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
694 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
695 ist->resample_channels = ist->dec_ctx->channels;
696 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
699 case AVMEDIA_TYPE_DATA:
700 case AVMEDIA_TYPE_SUBTITLE: {
701 char *canvas_size = NULL;
703 ist->dec = avcodec_find_decoder(dec->codec_id);
704 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
705 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
707 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
708 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
713 case AVMEDIA_TYPE_ATTACHMENT:
714 case AVMEDIA_TYPE_UNKNOWN:
722 static void assert_file_overwrite(const char *filename)
724 if (file_overwrite && no_file_overwrite) {
725 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
729 if (!file_overwrite) {
730 const char *proto_name = avio_find_protocol_name(filename);
731 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
732 if (stdin_interaction && !no_file_overwrite) {
733 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
736 signal(SIGINT, SIG_DFL);
738 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
744 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
751 static void dump_attachment(AVStream *st, const char *filename)
754 AVIOContext *out = NULL;
755 AVDictionaryEntry *e;
757 if (!st->codec->extradata_size) {
758 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
759 nb_input_files - 1, st->index);
762 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
765 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
766 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
770 assert_file_overwrite(filename);
772 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
773 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
778 avio_write(out, st->codec->extradata, st->codec->extradata_size);
783 static int open_input_file(OptionsContext *o, const char *filename)
787 AVInputFormat *file_iformat = NULL;
791 AVDictionary *unused_opts = NULL;
792 AVDictionaryEntry *e = NULL;
793 int orig_nb_streams; // number of streams before avformat_find_stream_info
794 char * video_codec_name = NULL;
795 char * audio_codec_name = NULL;
796 char *subtitle_codec_name = NULL;
797 int scan_all_pmts_set = 0;
800 if (!(file_iformat = av_find_input_format(o->format))) {
801 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
806 if (!strcmp(filename, "-"))
809 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
810 strcmp(filename, "/dev/stdin");
812 /* get default parameters from command line */
813 ic = avformat_alloc_context();
815 print_error(filename, AVERROR(ENOMEM));
818 if (o->nb_audio_sample_rate) {
819 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
821 if (o->nb_audio_channels) {
822 /* because we set audio_channels based on both the "ac" and
823 * "channel_layout" options, we need to check that the specified
824 * demuxer actually has the "channels" option before setting it */
825 if (file_iformat && file_iformat->priv_class &&
826 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
827 AV_OPT_SEARCH_FAKE_OBJ)) {
828 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
831 if (o->nb_frame_rates) {
832 /* set the format-level framerate option;
833 * this is important for video grabbers, e.g. x11 */
834 if (file_iformat && file_iformat->priv_class &&
835 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
836 AV_OPT_SEARCH_FAKE_OBJ)) {
837 av_dict_set(&o->g->format_opts, "framerate",
838 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
841 if (o->nb_frame_sizes) {
842 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
844 if (o->nb_frame_pix_fmts)
845 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
847 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
848 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
849 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
851 ic->video_codec_id = video_codec_name ?
852 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
853 ic->audio_codec_id = audio_codec_name ?
854 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
855 ic->subtitle_codec_id= subtitle_codec_name ?
856 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
858 if (video_codec_name)
859 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
860 if (audio_codec_name)
861 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
862 if (subtitle_codec_name)
863 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
865 ic->flags |= AVFMT_FLAG_NONBLOCK;
866 ic->interrupt_callback = int_cb;
868 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
869 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
870 scan_all_pmts_set = 1;
872 /* open the input file with generic avformat function */
873 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
875 print_error(filename, err);
878 if (scan_all_pmts_set)
879 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
880 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
881 assert_avoptions(o->g->format_opts);
883 /* apply forced codec ids */
884 for (i = 0; i < ic->nb_streams; i++)
885 choose_decoder(o, ic, ic->streams[i]);
887 /* Set AVCodecContext options for avformat_find_stream_info */
888 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
889 orig_nb_streams = ic->nb_streams;
891 /* If not enough info to get the stream parameters, we decode the
892 first frames to get it. (used in mpeg case for example) */
893 ret = avformat_find_stream_info(ic, opts);
895 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
896 if (ic->nb_streams == 0) {
897 avformat_close_input(&ic);
902 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
903 /* add the stream start time */
904 if (ic->start_time != AV_NOPTS_VALUE)
905 timestamp += ic->start_time;
907 /* if seeking requested, we execute it */
908 if (o->start_time != AV_NOPTS_VALUE) {
909 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
911 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
912 filename, (double)timestamp / AV_TIME_BASE);
916 /* update the current parameters so that they match the one of the input stream */
917 add_input_streams(o, ic);
919 /* dump the file content */
920 av_dump_format(ic, nb_input_files, filename, 0);
922 GROW_ARRAY(input_files, nb_input_files);
923 f = av_mallocz(sizeof(*f));
926 input_files[nb_input_files - 1] = f;
929 f->ist_index = nb_input_streams - ic->nb_streams;
930 f->start_time = o->start_time;
931 f->recording_time = o->recording_time;
932 f->input_ts_offset = o->input_ts_offset;
933 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
934 f->nb_streams = ic->nb_streams;
935 f->rate_emu = o->rate_emu;
936 f->accurate_seek = o->accurate_seek;
938 /* check if all codec options have been used */
939 unused_opts = strip_specifiers(o->g->codec_opts);
940 for (i = f->ist_index; i < nb_input_streams; i++) {
942 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
943 AV_DICT_IGNORE_SUFFIX)))
944 av_dict_set(&unused_opts, e->key, NULL, 0);
948 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
949 const AVClass *class = avcodec_get_class();
950 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
951 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
952 const AVClass *fclass = avformat_get_class();
953 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
954 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
955 if (!option || foption)
959 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
960 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
961 "input file #%d (%s) is not a decoding option.\n", e->key,
962 option->help ? option->help : "", nb_input_files - 1,
967 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
968 "input file #%d (%s) has not been used for any stream. The most "
969 "likely reason is either wrong type (e.g. a video option with "
970 "no video streams) or that it is a private option of some decoder "
971 "which was not actually used for any stream.\n", e->key,
972 option->help ? option->help : "", nb_input_files - 1, filename);
974 av_dict_free(&unused_opts);
976 for (i = 0; i < o->nb_dump_attachment; i++) {
979 for (j = 0; j < ic->nb_streams; j++) {
980 AVStream *st = ic->streams[j];
982 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
983 dump_attachment(st, o->dump_attachment[i].u.str);
987 for (i = 0; i < orig_nb_streams; i++)
988 av_dict_free(&opts[i]);
994 static uint8_t *get_line(AVIOContext *s)
1000 if (avio_open_dyn_buf(&line) < 0) {
1001 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1005 while ((c = avio_r8(s)) && c != '\n')
1008 avio_close_dyn_buf(line, &buf);
1013 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1016 char filename[1000];
1017 const char *base[3] = { getenv("AVCONV_DATADIR"),
1022 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1026 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1027 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1028 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1031 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1032 i != 1 ? "" : "/.avconv", preset_name);
1033 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1039 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1041 char *codec_name = NULL;
1043 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1045 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1046 NULL, ost->st->codec->codec_type);
1047 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1048 } else if (!strcmp(codec_name, "copy"))
1049 ost->stream_copy = 1;
1051 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1052 ost->st->codec->codec_id = ost->enc->id;
1056 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1059 AVStream *st = avformat_new_stream(oc, NULL);
1060 int idx = oc->nb_streams - 1, ret = 0;
1061 char *bsf = NULL, *next, *codec_tag = NULL;
1062 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1067 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1071 if (oc->nb_streams - 1 < o->nb_streamid_map)
1072 st->id = o->streamid_map[oc->nb_streams - 1];
1074 GROW_ARRAY(output_streams, nb_output_streams);
1075 if (!(ost = av_mallocz(sizeof(*ost))))
1077 output_streams[nb_output_streams - 1] = ost;
1079 ost->file_index = nb_output_files - 1;
1082 st->codec->codec_type = type;
1083 choose_encoder(o, oc, ost);
1085 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1086 if (!ost->enc_ctx) {
1087 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1090 ost->enc_ctx->codec_type = type;
1093 AVIOContext *s = NULL;
1094 char *buf = NULL, *arg = NULL, *preset = NULL;
1096 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1098 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1099 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1102 if (!buf[0] || buf[0] == '#') {
1106 if (!(arg = strchr(buf, '='))) {
1107 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1111 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1113 } while (!s->eof_reached);
1117 av_log(NULL, AV_LOG_FATAL,
1118 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1119 preset, ost->file_index, ost->index);
1123 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1126 ost->max_frames = INT64_MAX;
1127 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1128 for (i = 0; i<o->nb_max_frames; i++) {
1129 char *p = o->max_frames[i].specifier;
1130 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1131 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1136 ost->copy_prior_start = -1;
1137 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1139 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1141 if (next = strchr(bsf, ','))
1143 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1144 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1148 bsfc_prev->next = bsfc;
1150 ost->bitstream_filters = bsfc;
1156 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1158 uint32_t tag = strtol(codec_tag, &next, 0);
1160 tag = AV_RL32(codec_tag);
1161 ost->enc_ctx->codec_tag = tag;
1164 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1166 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1167 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1170 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1171 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1173 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1175 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1176 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1177 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1179 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1181 ost->source_index = source_index;
1182 if (source_index >= 0) {
1183 ost->sync_ist = input_streams[source_index];
1184 input_streams[source_index]->discard = 0;
1185 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1187 ost->last_mux_dts = AV_NOPTS_VALUE;
1192 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1195 const char *p = str;
1202 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1209 /* read file contents into a string */
1210 static uint8_t *read_file(const char *filename)
1212 AVIOContext *pb = NULL;
1213 AVIOContext *dyn_buf = NULL;
1214 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1215 uint8_t buf[1024], *str;
1218 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1222 ret = avio_open_dyn_buf(&dyn_buf);
1227 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1228 avio_write(dyn_buf, buf, ret);
1229 avio_w8(dyn_buf, 0);
1232 ret = avio_close_dyn_buf(dyn_buf, &str);
1238 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1241 AVStream *st = ost->st;
1243 if (ost->filters_script && ost->filters) {
1244 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1245 "output stream #%d:%d.\n", nb_output_files, st->index);
1249 if (ost->filters_script)
1250 return read_file(ost->filters_script);
1251 else if (ost->filters)
1252 return av_strdup(ost->filters);
1254 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1258 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1259 const OutputStream *ost, enum AVMediaType type)
1261 if (ost->filters_script || ost->filters) {
1262 av_log(NULL, AV_LOG_ERROR,
1263 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1264 "Filtering and streamcopy cannot be used together.\n",
1265 ost->filters ? "Filtergraph" : "Filtergraph script",
1266 ost->filters ? ost->filters : ost->filters_script,
1267 av_get_media_type_string(type), ost->file_index, ost->index);
1272 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1276 AVCodecContext *video_enc;
1277 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1279 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1281 video_enc = ost->enc_ctx;
1283 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1284 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1285 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1288 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1289 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1291 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1292 if (frame_aspect_ratio) {
1294 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1295 q.num <= 0 || q.den <= 0) {
1296 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1299 ost->frame_aspect_ratio = q;
1302 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1303 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1305 if (!ost->stream_copy) {
1306 const char *p = NULL;
1307 char *frame_size = NULL;
1308 char *frame_pix_fmt = NULL;
1309 char *intra_matrix = NULL, *inter_matrix = NULL;
1310 char *chroma_intra_matrix = NULL;
1314 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1315 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1316 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1320 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1321 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1322 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1323 ost->keep_pix_fmt = 1;
1324 if (!*++frame_pix_fmt)
1325 frame_pix_fmt = NULL;
1327 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1328 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1331 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1334 video_enc->gop_size = 0;
1335 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1337 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1338 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1341 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1343 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1344 if (chroma_intra_matrix) {
1345 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1347 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1350 av_codec_set_chroma_intra_matrix(video_enc, p);
1351 parse_matrix_coeffs(p, chroma_intra_matrix);
1353 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1355 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1356 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1359 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1362 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1363 for (i = 0; p; i++) {
1365 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1367 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1370 /* FIXME realloc failure */
1371 video_enc->rc_override =
1372 av_realloc(video_enc->rc_override,
1373 sizeof(RcOverride) * (i + 1));
1374 video_enc->rc_override[i].start_frame = start;
1375 video_enc->rc_override[i].end_frame = end;
1377 video_enc->rc_override[i].qscale = q;
1378 video_enc->rc_override[i].quality_factor = 1.0;
1381 video_enc->rc_override[i].qscale = 0;
1382 video_enc->rc_override[i].quality_factor = -q/100.0;
1387 video_enc->rc_override_count = i;
1390 video_enc->flags|= CODEC_FLAG_PSNR;
1393 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1396 video_enc->flags |= CODEC_FLAG_PASS1;
1397 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1400 video_enc->flags |= CODEC_FLAG_PASS2;
1401 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1405 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1406 if (ost->logfile_prefix &&
1407 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1410 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1411 if (ost->forced_keyframes)
1412 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1414 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1416 ost->top_field_first = -1;
1417 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1420 ost->avfilter = get_ost_filters(o, oc, ost);
1424 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1427 if (ost->stream_copy)
1428 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1433 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1438 AVCodecContext *audio_enc;
1440 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1443 audio_enc = ost->enc_ctx;
1444 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1446 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1447 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1449 if (!ost->stream_copy) {
1450 char *sample_fmt = NULL;
1452 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1454 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1456 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1457 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1461 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1463 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1464 ost->apad = av_strdup(ost->apad);
1466 ost->avfilter = get_ost_filters(o, oc, ost);
1470 /* check for channel mapping for this audio stream */
1471 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1472 AudioChannelMap *map = &o->audio_channel_maps[n];
1473 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1474 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1477 if (map->channel_idx == -1) {
1479 } else if (ost->source_index < 0) {
1480 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1481 ost->file_index, ost->st->index);
1484 ist = input_streams[ost->source_index];
1487 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1488 if (av_reallocp_array(&ost->audio_channels_map,
1489 ost->audio_channels_mapped + 1,
1490 sizeof(*ost->audio_channels_map)
1494 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1500 if (ost->stream_copy)
1501 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1506 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1510 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1511 if (!ost->stream_copy) {
1512 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1519 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1521 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1522 ost->stream_copy = 1;
1527 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1531 AVCodecContext *subtitle_enc;
1533 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1535 subtitle_enc = ost->enc_ctx;
1537 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1539 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1541 if (!ost->stream_copy) {
1542 char *frame_size = NULL;
1544 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1545 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1546 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1554 /* arg format is "output-stream-index:streamid-value". */
1555 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1557 OptionsContext *o = optctx;
1562 av_strlcpy(idx_str, arg, sizeof(idx_str));
1563 p = strchr(idx_str, ':');
1565 av_log(NULL, AV_LOG_FATAL,
1566 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1571 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1572 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1573 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1577 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1579 AVFormatContext *is = ifile->ctx;
1580 AVFormatContext *os = ofile->ctx;
1584 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1586 return AVERROR(ENOMEM);
1589 for (i = 0; i < is->nb_chapters; i++) {
1590 AVChapter *in_ch = is->chapters[i], *out_ch;
1591 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1592 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1593 AV_TIME_BASE_Q, in_ch->time_base);
1594 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1595 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1598 if (in_ch->end < ts_off)
1600 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1603 out_ch = av_mallocz(sizeof(AVChapter));
1605 return AVERROR(ENOMEM);
1607 out_ch->id = in_ch->id;
1608 out_ch->time_base = in_ch->time_base;
1609 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1610 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1613 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1615 os->chapters[os->nb_chapters++] = out_ch;
1620 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1623 AVFormatContext *ic = avformat_alloc_context();
1625 ic->interrupt_callback = int_cb;
1626 err = avformat_open_input(&ic, filename, NULL, NULL);
1629 /* copy stream format */
1630 for(i=0;i<ic->nb_streams;i++) {
1634 AVCodecContext *avctx;
1636 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1638 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1639 return AVERROR(EINVAL);
1641 ost = new_output_stream(o, s, codec->type, -1);
1646 // FIXME: a more elegant solution is needed
1647 memcpy(st, ic->streams[i], sizeof(AVStream));
1649 st->info = av_malloc(sizeof(*st->info));
1650 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1652 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1654 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1655 choose_sample_fmt(st, codec);
1656 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1657 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1658 avcodec_copy_context(ost->enc_ctx, st->codec);
1659 if (ost->enc_ctx->priv_data) {
1660 av_opt_free(ost->enc_ctx->priv_data);
1661 av_freep(&ost->enc_ctx->priv_data);
1665 avformat_close_input(&ic);
1669 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1670 AVFormatContext *oc)
1674 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1675 ofilter->out_tmp->pad_idx)) {
1676 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1677 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1679 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1684 ost->source_index = -1;
1685 ost->filter = ofilter;
1689 if (ost->stream_copy) {
1690 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1691 "which is fed from a complex filtergraph. Filtering and streamcopy "
1692 "cannot be used together.\n", ost->file_index, ost->index);
1696 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1697 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1698 av_log(NULL, AV_LOG_ERROR,
1699 "%s '%s' was specified through the %s option "
1700 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1701 "%s and -filter_complex cannot be used together for the same stream.\n",
1702 ost->filters ? "Filtergraph" : "Filtergraph script",
1703 ost->filters ? ost->filters : ost->filters_script,
1704 opt, ost->file_index, ost->index, opt);
1708 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1709 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1712 avfilter_inout_free(&ofilter->out_tmp);
1715 static int configure_complex_filters(void)
1719 for (i = 0; i < nb_filtergraphs; i++)
1720 if (!filtergraphs[i]->graph &&
1721 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1726 static int open_output_file(OptionsContext *o, const char *filename)
1728 AVFormatContext *oc;
1730 AVOutputFormat *file_oformat;
1734 AVDictionary *unused_opts = NULL;
1735 AVDictionaryEntry *e = NULL;
1737 if (configure_complex_filters() < 0) {
1738 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1742 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1743 o->stop_time = INT64_MAX;
1744 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1747 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1748 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1749 if (o->stop_time <= start_time) {
1750 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1753 o->recording_time = o->stop_time - start_time;
1757 GROW_ARRAY(output_files, nb_output_files);
1758 of = av_mallocz(sizeof(*of));
1761 output_files[nb_output_files - 1] = of;
1763 of->ost_index = nb_output_streams;
1764 of->recording_time = o->recording_time;
1765 of->start_time = o->start_time;
1766 of->limit_filesize = o->limit_filesize;
1767 of->shortest = o->shortest;
1768 av_dict_copy(&of->opts, o->g->format_opts, 0);
1770 if (!strcmp(filename, "-"))
1773 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1775 print_error(filename, err);
1780 if (o->recording_time != INT64_MAX)
1781 oc->duration = o->recording_time;
1783 file_oformat= oc->oformat;
1784 oc->interrupt_callback = int_cb;
1786 /* create streams for all unlabeled output pads */
1787 for (i = 0; i < nb_filtergraphs; i++) {
1788 FilterGraph *fg = filtergraphs[i];
1789 for (j = 0; j < fg->nb_outputs; j++) {
1790 OutputFilter *ofilter = fg->outputs[j];
1792 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1795 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1796 ofilter->out_tmp->pad_idx)) {
1797 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1798 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1799 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1801 init_output_filter(ofilter, o, oc);
1805 /* ffserver seeking with date=... needs a date reference */
1806 if (!strcmp(file_oformat->name, "ffm") &&
1807 av_strstart(filename, "http:", NULL)) {
1808 int err = parse_option(o, "metadata", "creation_time=now", options);
1810 print_error(filename, err);
1815 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1816 av_strstart(filename, "http:", NULL)) {
1818 /* special case for files sent to ffserver: we get the stream
1819 parameters from ffserver */
1820 int err = read_ffserver_streams(o, oc, filename);
1822 print_error(filename, err);
1825 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1826 ost = output_streams[j];
1827 for (i = 0; i < nb_input_streams; i++) {
1828 ist = input_streams[i];
1829 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1831 ost->source_index= i;
1832 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1833 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1835 ist->st->discard = ist->user_set_discard;
1840 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1844 } else if (!o->nb_stream_maps) {
1845 char *subtitle_codec_name = NULL;
1846 /* pick the "best" stream of each type */
1848 /* video: highest resolution */
1849 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1850 int area = 0, idx = -1;
1851 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1852 for (i = 0; i < nb_input_streams; i++) {
1854 ist = input_streams[i];
1855 new_area = ist->st->codec->width * ist->st->codec->height;
1856 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1858 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1860 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1867 new_video_stream(o, oc, idx);
1870 /* audio: most channels */
1871 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1872 int channels = 0, idx = -1;
1873 for (i = 0; i < nb_input_streams; i++) {
1874 ist = input_streams[i];
1875 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1876 ist->st->codec->channels > channels) {
1877 channels = ist->st->codec->channels;
1882 new_audio_stream(o, oc, idx);
1885 /* subtitles: pick first */
1886 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1887 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1888 for (i = 0; i < nb_input_streams; i++)
1889 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1890 AVCodecDescriptor const *input_descriptor =
1891 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1892 AVCodecDescriptor const *output_descriptor = NULL;
1893 AVCodec const *output_codec =
1894 avcodec_find_encoder(oc->oformat->subtitle_codec);
1895 int input_props = 0, output_props = 0;
1897 output_descriptor = avcodec_descriptor_get(output_codec->id);
1898 if (input_descriptor)
1899 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1900 if (output_descriptor)
1901 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1902 if (subtitle_codec_name ||
1903 input_props & output_props ||
1904 // Map dvb teletext which has neither property to any output subtitle encoder
1905 input_descriptor && output_descriptor &&
1906 (!input_descriptor->props ||
1907 !output_descriptor->props)) {
1908 new_subtitle_stream(o, oc, i);
1913 /* do something with data? */
1915 for (i = 0; i < o->nb_stream_maps; i++) {
1916 StreamMap *map = &o->stream_maps[i];
1921 if (map->linklabel) {
1923 OutputFilter *ofilter = NULL;
1926 for (j = 0; j < nb_filtergraphs; j++) {
1927 fg = filtergraphs[j];
1928 for (k = 0; k < fg->nb_outputs; k++) {
1929 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1930 if (out && !strcmp(out->name, map->linklabel)) {
1931 ofilter = fg->outputs[k];
1938 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1939 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1942 init_output_filter(ofilter, o, oc);
1944 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1946 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1947 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1949 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1951 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1953 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1956 switch (ist->st->codec->codec_type) {
1957 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1958 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1959 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1960 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1961 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1963 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1964 map->file_index, map->stream_index);
1971 /* handle attached files */
1972 for (i = 0; i < o->nb_attachments; i++) {
1974 uint8_t *attachment;
1978 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1979 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1983 if ((len = avio_size(pb)) <= 0) {
1984 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1988 if (!(attachment = av_malloc(len))) {
1989 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1993 avio_read(pb, attachment, len);
1995 ost = new_attachment_stream(o, oc, -1);
1996 ost->stream_copy = 0;
1997 ost->attachment_filename = o->attachments[i];
1999 ost->enc_ctx->extradata = attachment;
2000 ost->enc_ctx->extradata_size = len;
2002 p = strrchr(o->attachments[i], '/');
2003 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2007 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2008 AVDictionaryEntry *e;
2009 ost = output_streams[i];
2011 if ((ost->stream_copy || ost->attachment_filename)
2012 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2013 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2014 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2018 /* check if all codec options have been used */
2019 unused_opts = strip_specifiers(o->g->codec_opts);
2020 for (i = of->ost_index; i < nb_output_streams; i++) {
2022 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2023 AV_DICT_IGNORE_SUFFIX)))
2024 av_dict_set(&unused_opts, e->key, NULL, 0);
2028 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2029 const AVClass *class = avcodec_get_class();
2030 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2031 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2032 const AVClass *fclass = avformat_get_class();
2033 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2034 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2035 if (!option || foption)
2039 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2040 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2041 "output file #%d (%s) is not an encoding option.\n", e->key,
2042 option->help ? option->help : "", nb_output_files - 1,
2047 // gop_timecode is injected by generic code but not always used
2048 if (!strcmp(e->key, "gop_timecode"))
2051 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2052 "output file #%d (%s) has not been used for any stream. The most "
2053 "likely reason is either wrong type (e.g. a video option with "
2054 "no video streams) or that it is a private option of some encoder "
2055 "which was not actually used for any stream.\n", e->key,
2056 option->help ? option->help : "", nb_output_files - 1, filename);
2058 av_dict_free(&unused_opts);
2060 /* check filename in case of an image number is expected */
2061 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2062 if (!av_filename_number_test(oc->filename)) {
2063 print_error(oc->filename, AVERROR(EINVAL));
2068 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2069 /* test if it already exists to avoid losing precious files */
2070 assert_file_overwrite(filename);
2073 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2074 &oc->interrupt_callback,
2076 print_error(filename, err);
2079 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2080 assert_file_overwrite(filename);
2082 if (o->mux_preload) {
2083 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2085 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2088 for (i = 0; i < o->nb_metadata_map; i++) {
2090 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2092 if (in_file_index >= nb_input_files) {
2093 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2096 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2097 in_file_index >= 0 ?
2098 input_files[in_file_index]->ctx : NULL, o);
2102 if (o->chapters_input_file >= nb_input_files) {
2103 if (o->chapters_input_file == INT_MAX) {
2104 /* copy chapters from the first input file that has them*/
2105 o->chapters_input_file = -1;
2106 for (i = 0; i < nb_input_files; i++)
2107 if (input_files[i]->ctx->nb_chapters) {
2108 o->chapters_input_file = i;
2112 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2113 o->chapters_input_file);
2117 if (o->chapters_input_file >= 0)
2118 copy_chapters(input_files[o->chapters_input_file], of,
2119 !o->metadata_chapters_manual);
2121 /* copy global metadata by default */
2122 if (!o->metadata_global_manual && nb_input_files){
2123 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2124 AV_DICT_DONT_OVERWRITE);
2125 if(o->recording_time != INT64_MAX)
2126 av_dict_set(&oc->metadata, "duration", NULL, 0);
2127 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2129 if (!o->metadata_streams_manual)
2130 for (i = of->ost_index; i < nb_output_streams; i++) {
2132 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2134 ist = input_streams[output_streams[i]->source_index];
2135 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2136 if (!output_streams[i]->stream_copy)
2137 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2140 /* process manually set metadata */
2141 for (i = 0; i < o->nb_metadata; i++) {
2144 const char *stream_spec;
2145 int index = 0, j, ret = 0;
2147 val = strchr(o->metadata[i].u.str, '=');
2149 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2150 o->metadata[i].u.str);
2155 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2157 for (j = 0; j < oc->nb_streams; j++) {
2158 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2159 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2170 if (index < 0 || index >= oc->nb_chapters) {
2171 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2174 m = &oc->chapters[index]->metadata;
2177 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2180 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2187 static int opt_target(void *optctx, const char *opt, const char *arg)
2189 OptionsContext *o = optctx;
2190 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2191 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2193 if (!strncmp(arg, "pal-", 4)) {
2196 } else if (!strncmp(arg, "ntsc-", 5)) {
2199 } else if (!strncmp(arg, "film-", 5)) {
2203 /* Try to determine PAL/NTSC by peeking in the input files */
2204 if (nb_input_files) {
2206 for (j = 0; j < nb_input_files; j++) {
2207 for (i = 0; i < input_files[j]->nb_streams; i++) {
2208 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2209 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2212 fr = c->time_base.den * 1000 / c->time_base.num;
2216 } else if ((fr == 29970) || (fr == 23976)) {
2221 if (norm != UNKNOWN)
2225 if (norm != UNKNOWN)
2226 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2229 if (norm == UNKNOWN) {
2230 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2231 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2232 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2236 if (!strcmp(arg, "vcd")) {
2237 opt_video_codec(o, "c:v", "mpeg1video");
2238 opt_audio_codec(o, "c:a", "mp2");
2239 parse_option(o, "f", "vcd", options);
2241 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2242 parse_option(o, "r", frame_rates[norm], options);
2243 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2245 opt_default(NULL, "b:v", "1150000");
2246 opt_default(NULL, "maxrate", "1150000");
2247 opt_default(NULL, "minrate", "1150000");
2248 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2250 opt_default(NULL, "b:a", "224000");
2251 parse_option(o, "ar", "44100", options);
2252 parse_option(o, "ac", "2", options);
2254 opt_default(NULL, "packetsize", "2324");
2255 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2257 /* We have to offset the PTS, so that it is consistent with the SCR.
2258 SCR starts at 36000, but the first two packs contain only padding
2259 and the first pack from the other stream, respectively, may also have
2260 been written before.
2261 So the real data starts at SCR 36000+3*1200. */
2262 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2263 } else if (!strcmp(arg, "svcd")) {
2265 opt_video_codec(o, "c:v", "mpeg2video");
2266 opt_audio_codec(o, "c:a", "mp2");
2267 parse_option(o, "f", "svcd", options);
2269 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2270 parse_option(o, "r", frame_rates[norm], options);
2271 parse_option(o, "pix_fmt", "yuv420p", options);
2272 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2274 opt_default(NULL, "b:v", "2040000");
2275 opt_default(NULL, "maxrate", "2516000");
2276 opt_default(NULL, "minrate", "0"); // 1145000;
2277 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2278 opt_default(NULL, "scan_offset", "1");
2280 opt_default(NULL, "b:a", "224000");
2281 parse_option(o, "ar", "44100", options);
2283 opt_default(NULL, "packetsize", "2324");
2285 } else if (!strcmp(arg, "dvd")) {
2287 opt_video_codec(o, "c:v", "mpeg2video");
2288 opt_audio_codec(o, "c:a", "ac3");
2289 parse_option(o, "f", "dvd", options);
2291 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2292 parse_option(o, "r", frame_rates[norm], options);
2293 parse_option(o, "pix_fmt", "yuv420p", options);
2294 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2296 opt_default(NULL, "b:v", "6000000");
2297 opt_default(NULL, "maxrate", "9000000");
2298 opt_default(NULL, "minrate", "0"); // 1500000;
2299 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2301 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2302 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2304 opt_default(NULL, "b:a", "448000");
2305 parse_option(o, "ar", "48000", options);
2307 } else if (!strncmp(arg, "dv", 2)) {
2309 parse_option(o, "f", "dv", options);
2311 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2312 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2313 norm == PAL ? "yuv420p" : "yuv411p", options);
2314 parse_option(o, "r", frame_rates[norm], options);
2316 parse_option(o, "ar", "48000", options);
2317 parse_option(o, "ac", "2", options);
2320 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2321 return AVERROR(EINVAL);
2324 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2325 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2330 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2332 av_free (vstats_filename);
2333 vstats_filename = av_strdup (arg);
2337 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2340 time_t today2 = time(NULL);
2341 struct tm *today = localtime(&today2);
2343 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2345 return opt_vstats_file(NULL, opt, filename);
2348 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2350 OptionsContext *o = optctx;
2351 return parse_option(o, "frames:v", arg, options);
2354 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2356 OptionsContext *o = optctx;
2357 return parse_option(o, "frames:a", arg, options);
2360 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2362 OptionsContext *o = optctx;
2363 return parse_option(o, "frames:d", arg, options);
2366 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2369 AVDictionary *cbak = codec_opts;
2370 AVDictionary *fbak = format_opts;
2374 ret = opt_default(NULL, opt, arg);
2376 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2377 av_dict_copy(&o->g->format_opts, format_opts, 0);
2378 av_dict_free(&codec_opts);
2379 av_dict_free(&format_opts);
2386 static int opt_preset(void *optctx, const char *opt, const char *arg)
2388 OptionsContext *o = optctx;
2390 char filename[1000], line[1000], tmp_line[1000];
2391 const char *codec_name = NULL;
2395 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2397 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2398 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2399 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2401 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2405 while (fgets(line, sizeof(line), f)) {
2406 char *key = tmp_line, *value, *endptr;
2408 if (strcspn(line, "#\n\r") == 0)
2410 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2411 if (!av_strtok(key, "=", &value) ||
2412 !av_strtok(value, "\r\n", &endptr)) {
2413 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2416 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2418 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2419 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2420 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2421 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2422 else if (opt_default_new(o, key, value) < 0) {
2423 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2424 filename, line, key, value);
2434 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2436 OptionsContext *o = optctx;
2437 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2438 int ret = parse_option(o, s, arg, options);
2443 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2445 OptionsContext *o = optctx;
2447 if(!strcmp(opt, "ab")){
2448 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2450 } else if(!strcmp(opt, "b")){
2451 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2452 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2455 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2459 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2461 OptionsContext *o = optctx;
2464 if(!strcmp(opt, "qscale")){
2465 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2466 return parse_option(o, "q:v", arg, options);
2468 s = av_asprintf("q%s", opt + 6);
2469 ret = parse_option(o, s, arg, options);
2474 static int opt_profile(void *optctx, const char *opt, const char *arg)
2476 OptionsContext *o = optctx;
2477 if(!strcmp(opt, "profile")){
2478 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2479 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2482 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2486 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2488 OptionsContext *o = optctx;
2489 return parse_option(o, "filter:v", arg, options);
2492 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2494 OptionsContext *o = optctx;
2495 return parse_option(o, "filter:a", arg, options);
2498 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2500 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2501 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2502 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2503 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2505 if (video_sync_method == VSYNC_AUTO)
2506 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2510 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2512 OptionsContext *o = optctx;
2513 char *tcr = av_asprintf("timecode=%s", arg);
2514 int ret = parse_option(o, "metadata:g", tcr, options);
2516 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2521 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2523 OptionsContext *o = optctx;
2524 char layout_str[32];
2527 int ret, channels, ac_str_size;
2530 layout = av_get_channel_layout(arg);
2532 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2533 return AVERROR(EINVAL);
2535 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2536 ret = opt_default_new(o, opt, layout_str);
2540 /* set 'ac' option based on channel layout */
2541 channels = av_get_channel_layout_nb_channels(layout);
2542 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2543 stream_str = strchr(opt, ':');
2544 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2545 ac_str = av_mallocz(ac_str_size);
2547 return AVERROR(ENOMEM);
2548 av_strlcpy(ac_str, "ac", 3);
2550 av_strlcat(ac_str, stream_str, ac_str_size);
2551 ret = parse_option(o, ac_str, layout_str, options);
2557 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2559 OptionsContext *o = optctx;
2560 return parse_option(o, "q:a", arg, options);
2563 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2565 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2566 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2567 return AVERROR(ENOMEM);
2568 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2569 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2570 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2571 return AVERROR(ENOMEM);
2575 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2577 uint8_t *graph_desc = read_file(arg);
2579 return AVERROR(EINVAL);
2581 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2582 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2583 return AVERROR(ENOMEM);
2584 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2585 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2589 void show_help_default(const char *opt, const char *arg)
2591 /* per-file options have at least one of those set */
2592 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2593 int show_advanced = 0, show_avoptions = 0;
2596 if (!strcmp(opt, "long"))
2598 else if (!strcmp(opt, "full"))
2599 show_advanced = show_avoptions = 1;
2601 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2606 printf("Getting help:\n"
2607 " -h -- print basic options\n"
2608 " -h long -- print more options\n"
2609 " -h full -- print all options (including all format and codec specific options, very long)\n"
2610 " See man %s for detailed description of the options.\n"
2611 "\n", program_name);
2613 show_help_options(options, "Print help / information / capabilities:",
2616 show_help_options(options, "Global options (affect whole program "
2617 "instead of just one file:",
2618 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2620 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2621 per_file | OPT_EXIT, 0);
2623 show_help_options(options, "Per-file main options:", 0,
2624 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2625 OPT_EXIT, per_file);
2627 show_help_options(options, "Advanced per-file options:",
2628 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2630 show_help_options(options, "Video options:",
2631 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2633 show_help_options(options, "Advanced Video options:",
2634 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2636 show_help_options(options, "Audio options:",
2637 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2639 show_help_options(options, "Advanced Audio options:",
2640 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2641 show_help_options(options, "Subtitle options:",
2642 OPT_SUBTITLE, 0, 0);
2645 if (show_avoptions) {
2646 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2647 show_help_children(avcodec_get_class(), flags);
2648 show_help_children(avformat_get_class(), flags);
2650 show_help_children(sws_get_class(), flags);
2652 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2653 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2657 void show_usage(void)
2659 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2660 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2661 av_log(NULL, AV_LOG_INFO, "\n");
2669 static const OptionGroupDef groups[] = {
2670 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2671 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2674 static int open_files(OptionGroupList *l, const char *inout,
2675 int (*open_file)(OptionsContext*, const char*))
2679 for (i = 0; i < l->nb_groups; i++) {
2680 OptionGroup *g = &l->groups[i];
2686 ret = parse_optgroup(&o, g);
2688 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2689 "%s.\n", inout, g->arg);
2693 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2694 ret = open_file(&o, g->arg);
2697 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2701 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2707 int ffmpeg_parse_options(int argc, char **argv)
2709 OptionParseContext octx;
2713 memset(&octx, 0, sizeof(octx));
2715 /* split the commandline into an internal representation */
2716 ret = split_commandline(&octx, argc, argv, options, groups,
2717 FF_ARRAY_ELEMS(groups));
2719 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2723 /* apply global options */
2724 ret = parse_optgroup(NULL, &octx.global_opts);
2726 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2730 /* open input files */
2731 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2733 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2737 /* open output files */
2738 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2740 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2745 uninit_parse_context(&octx);
2747 av_strerror(ret, error, sizeof(error));
2748 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2753 static int opt_progress(void *optctx, const char *opt, const char *arg)
2755 AVIOContext *avio = NULL;
2758 if (!strcmp(arg, "-"))
2760 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2762 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2763 arg, av_err2str(ret));
2766 progress_avio = avio;
2770 #define OFFSET(x) offsetof(OptionsContext, x)
2771 const OptionDef options[] = {
2773 #include "cmdutils_common_opts.h"
2774 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2775 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2776 "force format", "fmt" },
2777 { "y", OPT_BOOL, { &file_overwrite },
2778 "overwrite output files" },
2779 { "n", OPT_BOOL, { &no_file_overwrite },
2780 "never overwrite output files" },
2781 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2782 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2783 "codec name", "codec" },
2784 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2785 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2786 "codec name", "codec" },
2787 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2788 OPT_OUTPUT, { .off = OFFSET(presets) },
2789 "preset name", "preset" },
2790 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2791 OPT_OUTPUT, { .func_arg = opt_map },
2792 "set input stream mapping",
2793 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2794 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2795 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2796 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2797 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2798 "set metadata information of outfile from infile",
2799 "outfile[,metadata]:infile[,metadata]" },
2800 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2801 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2802 "set chapters mapping", "input_file_index" },
2803 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2804 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2805 "record or transcode \"duration\" seconds of audio/video",
2807 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2808 "record or transcode stop time", "time_stop" },
2809 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2810 "set the limit file size in bytes", "limit_size" },
2811 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2812 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2813 "set the start time offset", "time_off" },
2814 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2815 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2816 "enable/disable accurate seeking with -ss" },
2817 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2818 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2819 "set the input ts offset", "time_off" },
2820 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2821 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2822 "set the input ts scale", "scale" },
2823 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2824 "set the recording timestamp ('now' to set the current time)", "time" },
2825 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2826 "add metadata", "string=string" },
2827 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2828 OPT_OUTPUT, { .func_arg = opt_data_frames },
2829 "set the number of data frames to output", "number" },
2830 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2831 "add timings for benchmarking" },
2832 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2833 "add timings for each task" },
2834 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2835 "write program-readable progress information", "url" },
2836 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2837 "enable or disable interaction on standard input" },
2838 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2839 "set max runtime in seconds", "limit" },
2840 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2841 "dump each input packet" },
2842 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2843 "when dumping packets, also dump the payload" },
2844 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2845 OPT_INPUT, { .off = OFFSET(rate_emu) },
2846 "read input at native frame rate", "" },
2847 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2848 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2849 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2850 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2851 "video sync method", "" },
2852 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2853 "audio sync method", "" },
2854 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2855 "audio drift threshold", "threshold" },
2856 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2857 "copy timestamps" },
2858 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2859 "shift input timestamps to start at 0 when using copyts" },
2860 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2861 "copy input stream time base when stream copying", "mode" },
2862 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2863 OPT_OUTPUT, { .off = OFFSET(shortest) },
2864 "finish encoding within shortest input" },
2865 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2866 OPT_OUTPUT, { .off = OFFSET(apad) },
2868 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2869 "timestamp discontinuity delta threshold", "threshold" },
2870 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2871 "timestamp error delta threshold", "threshold" },
2872 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2873 "exit on error", "error" },
2874 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2875 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2876 "copy initial non-keyframes" },
2877 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2878 "copy or discard frames before start time" },
2879 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2880 "set the number of frames to output", "number" },
2881 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2882 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2883 "force codec tag/fourcc", "fourcc/tag" },
2884 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2885 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2886 "use fixed quality scale (VBR)", "q" },
2887 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2888 OPT_OUTPUT, { .func_arg = opt_qscale },
2889 "use fixed quality scale (VBR)", "q" },
2890 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2891 "set profile", "profile" },
2892 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2893 "set stream filtergraph", "filter_graph" },
2894 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2895 "read stream filtergraph description from a file", "filename" },
2896 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2897 "reinit filtergraph on input parameter changes", "" },
2898 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2899 "create a complex filtergraph", "graph_description" },
2900 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2901 "create a complex filtergraph", "graph_description" },
2902 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2903 "read complex filtergraph description from a file", "filename" },
2904 { "stats", OPT_BOOL, { &print_stats },
2905 "print progress report during encoding", },
2906 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2907 OPT_OUTPUT, { .func_arg = opt_attach },
2908 "add an attachment to the output file", "filename" },
2909 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2910 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2911 "extract an attachment into a file", "filename" },
2912 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2913 "print timestamp debugging info" },
2914 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2915 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2916 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2917 OPT_INPUT, { .off = OFFSET(discard) },
2921 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2922 "set the number of video frames to output", "number" },
2923 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2924 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2925 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2926 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2927 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2928 "set frame size (WxH or abbreviation)", "size" },
2929 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2930 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2931 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2932 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2933 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2934 "set pixel format", "format" },
2935 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2936 "set the number of bits per raw sample", "number" },
2937 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2938 "deprecated use -g 1" },
2939 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2941 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2942 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2943 "rate control override for specific intervals", "override" },
2944 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2945 OPT_OUTPUT, { .func_arg = opt_video_codec },
2946 "force video codec ('copy' to copy stream)", "codec" },
2947 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2949 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2951 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2952 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2953 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2954 "select the pass number (1 to 3)", "n" },
2955 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2956 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2957 "select two pass log file name prefix", "prefix" },
2958 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2959 "this option is deprecated, use the yadif filter instead" },
2960 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2961 "calculate PSNR of compressed frames" },
2962 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2963 "dump video coding statistics to file" },
2964 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2965 "dump video coding statistics to file", "file" },
2966 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2967 "set video filters", "filter_graph" },
2968 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2969 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2970 "specify intra matrix coeffs", "matrix" },
2971 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2972 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2973 "specify inter matrix coeffs", "matrix" },
2974 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2975 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2976 "specify intra matrix coeffs", "matrix" },
2977 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2978 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2979 "top=1/bottom=0/auto=-1 field first", "" },
2980 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2981 OPT_OUTPUT, { .func_arg = opt_old2new },
2982 "force video tag/fourcc", "fourcc/tag" },
2983 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2984 "show QP histogram" },
2985 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2986 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2987 "force the selected framerate, disable the best supported framerate selection" },
2988 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2989 OPT_OUTPUT, { .func_arg = opt_streamid },
2990 "set the value of an outfile streamid", "streamIndex:value" },
2991 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2992 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2993 "force key frames at specified timestamps", "timestamps" },
2994 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2995 "audio bitrate (please use -b:a)", "bitrate" },
2996 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2997 "video bitrate (please use -b:v)", "bitrate" },
2998 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2999 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3000 "use HW accelerated decoding", "hwaccel name" },
3001 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3002 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3003 "select a device for HW acceleration" "devicename" },
3005 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3009 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3010 "set the number of audio frames to output", "number" },
3011 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3012 "set audio quality (codec-specific)", "quality", },
3013 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3014 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3015 "set audio sampling rate (in Hz)", "rate" },
3016 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3017 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3018 "set number of audio channels", "channels" },
3019 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3021 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3022 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3023 "force audio codec ('copy' to copy stream)", "codec" },
3024 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3025 OPT_OUTPUT, { .func_arg = opt_old2new },
3026 "force audio tag/fourcc", "fourcc/tag" },
3027 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3028 "change audio volume (256=normal)" , "volume" },
3029 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3030 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3031 "set sample format", "format" },
3032 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3033 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3034 "set channel layout", "layout" },
3035 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3036 "set audio filters", "filter_graph" },
3037 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3038 "set the maximum number of channels to try to guess the channel layout" },
3040 /* subtitle options */
3041 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3042 "disable subtitle" },
3043 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3044 "force subtitle codec ('copy' to copy stream)", "codec" },
3045 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3046 , "force subtitle tag/fourcc", "fourcc/tag" },
3047 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3048 "fix subtitles duration" },
3049 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3050 "set canvas size (WxH or abbreviation)", "size" },
3053 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3054 "deprecated, use -channel", "channel" },
3055 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3056 "deprecated, use -standard", "standard" },
3057 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3060 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3061 "set the maximum demux-decode delay", "seconds" },
3062 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3063 "set the initial demux-decode delay", "seconds" },
3064 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3065 "override the options from ffserver", "" },
3067 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3068 "A comma-separated list of bitstream filters", "bitstream_filters" },
3069 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3070 "deprecated", "audio bitstream_filters" },
3071 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3072 "deprecated", "video bitstream_filters" },
3074 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3075 "set the audio options to the indicated preset", "preset" },
3076 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3077 "set the video options to the indicated preset", "preset" },
3078 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3079 "set the subtitle options to the indicated preset", "preset" },
3080 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3081 "set options from indicated preset file", "filename" },
3082 /* data codec support */
3083 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3084 "force data codec ('copy' to copy stream)", "codec" },
3085 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },