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;
96 int exit_on_error = 0;
99 int stdin_interaction = 1;
100 int frame_bits_per_raw_sample = 0;
101 float max_error_rate = 2.0/3;
104 static int intra_only = 0;
105 static int file_overwrite = 0;
106 static int no_file_overwrite = 0;
107 static int do_psnr = 0;
108 static int input_sync;
109 static int override_ffserver = 0;
111 static void uninit_options(OptionsContext *o)
113 const OptionDef *po = options;
116 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
118 void *dst = (uint8_t*)o + po->u.off;
120 if (po->flags & OPT_SPEC) {
121 SpecifierOpt **so = dst;
122 int i, *count = (int*)(so + 1);
123 for (i = 0; i < *count; i++) {
124 av_freep(&(*so)[i].specifier);
125 if (po->flags & OPT_STRING)
126 av_freep(&(*so)[i].u.str);
130 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
135 for (i = 0; i < o->nb_stream_maps; i++)
136 av_freep(&o->stream_maps[i].linklabel);
137 av_freep(&o->stream_maps);
138 av_freep(&o->audio_channel_maps);
139 av_freep(&o->streamid_map);
140 av_freep(&o->attachments);
143 static void init_options(OptionsContext *o)
145 memset(o, 0, sizeof(*o));
147 o->stop_time = INT64_MAX;
148 o->mux_max_delay = 0.7;
149 o->start_time = AV_NOPTS_VALUE;
150 o->recording_time = INT64_MAX;
151 o->limit_filesize = UINT64_MAX;
152 o->chapters_input_file = INT_MAX;
153 o->accurate_seek = 1;
156 /* return a copy of the input with the stream specifiers removed from the keys */
157 static AVDictionary *strip_specifiers(AVDictionary *dict)
159 AVDictionaryEntry *e = NULL;
160 AVDictionary *ret = NULL;
162 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
163 char *p = strchr(e->key, ':');
167 av_dict_set(&ret, e->key, e->value, 0);
174 static int opt_sameq(void *optctx, const char *opt, const char *arg)
176 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
177 "If you are looking for an option to preserve the quality (which is not "
178 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
180 return AVERROR(EINVAL);
183 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
185 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
186 return opt_default(optctx, "channel", arg);
189 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
191 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
192 return opt_default(optctx, "standard", arg);
195 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:a", arg, options);
201 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:v", arg, options);
207 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:s", arg, options);
213 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:d", arg, options);
219 static int opt_map(void *optctx, const char *opt, const char *arg)
221 OptionsContext *o = optctx;
223 int i, negative = 0, file_idx;
224 int sync_file_idx = -1, sync_stream_idx = 0;
232 map = av_strdup(arg);
234 /* parse sync stream first, just pick first matching stream */
235 if (sync = strchr(map, ',')) {
237 sync_file_idx = strtol(sync + 1, &sync, 0);
238 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
239 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
244 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
245 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
246 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
250 if (i == input_files[sync_file_idx]->nb_streams) {
251 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
252 "match any streams.\n", arg);
259 /* this mapping refers to lavfi output */
260 const char *c = map + 1;
261 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
262 m = &o->stream_maps[o->nb_stream_maps - 1];
263 m->linklabel = av_get_token(&c, "]");
265 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
269 file_idx = strtol(map, &p, 0);
270 if (file_idx >= nb_input_files || file_idx < 0) {
271 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
275 /* disable some already defined maps */
276 for (i = 0; i < o->nb_stream_maps; i++) {
277 m = &o->stream_maps[i];
278 if (file_idx == m->file_index &&
279 check_stream_specifier(input_files[m->file_index]->ctx,
280 input_files[m->file_index]->ctx->streams[m->stream_index],
281 *p == ':' ? p + 1 : p) > 0)
285 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
286 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
287 *p == ':' ? p + 1 : p) <= 0)
289 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
290 m = &o->stream_maps[o->nb_stream_maps - 1];
292 m->file_index = file_idx;
295 if (sync_file_idx >= 0) {
296 m->sync_file_index = sync_file_idx;
297 m->sync_stream_index = sync_stream_idx;
299 m->sync_file_index = file_idx;
300 m->sync_stream_index = i;
306 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
314 static int opt_attach(void *optctx, const char *opt, const char *arg)
316 OptionsContext *o = optctx;
317 GROW_ARRAY(o->attachments, o->nb_attachments);
318 o->attachments[o->nb_attachments - 1] = arg;
322 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
324 OptionsContext *o = optctx;
329 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
330 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
332 /* muted channel syntax */
333 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
334 if ((n == 1 || n == 3) && m->channel_idx == -1) {
335 m->file_idx = m->stream_idx = -1;
337 m->ofile_idx = m->ostream_idx = -1;
342 n = sscanf(arg, "%d.%d.%d:%d.%d",
343 &m->file_idx, &m->stream_idx, &m->channel_idx,
344 &m->ofile_idx, &m->ostream_idx);
346 if (n != 3 && n != 5) {
347 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
348 "[file.stream.channel|-1][:syncfile:syncstream]\n");
352 if (n != 5) // only file.stream.channel specified
353 m->ofile_idx = m->ostream_idx = -1;
356 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
361 if (m->stream_idx < 0 ||
362 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
363 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
364 m->file_idx, m->stream_idx);
367 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
368 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
369 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
370 m->file_idx, m->stream_idx);
373 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
375 m->file_idx, m->stream_idx, m->channel_idx);
382 * Parse a metadata specifier passed as 'arg' parameter.
383 * @param arg metadata string to parse
384 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
385 * @param index for type c/p, chapter/program index is written here
386 * @param stream_spec for type s, the stream specifier is written here
388 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
396 if (*(++arg) && *arg != ':') {
397 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
400 *stream_spec = *arg == ':' ? arg + 1 : "";
405 *index = strtol(++arg, NULL, 0);
408 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
415 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
417 AVDictionary **meta_in = NULL;
418 AVDictionary **meta_out = NULL;
420 char type_in, type_out;
421 const char *istream_spec = NULL, *ostream_spec = NULL;
422 int idx_in = 0, idx_out = 0;
424 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
425 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
428 if (type_out == 'g' || !*outspec)
429 o->metadata_global_manual = 1;
430 if (type_out == 's' || !*outspec)
431 o->metadata_streams_manual = 1;
432 if (type_out == 'c' || !*outspec)
433 o->metadata_chapters_manual = 1;
437 if (type_in == 'g' || type_out == 'g')
438 o->metadata_global_manual = 1;
439 if (type_in == 's' || type_out == 's')
440 o->metadata_streams_manual = 1;
441 if (type_in == 'c' || type_out == 'c')
442 o->metadata_chapters_manual = 1;
444 /* ic is NULL when just disabling automatic mappings */
448 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
449 if ((index) < 0 || (index) >= (nb_elems)) {\
450 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
455 #define SET_DICT(type, meta, context, index)\
458 meta = &context->metadata;\
461 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
462 meta = &context->chapters[index]->metadata;\
465 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
466 meta = &context->programs[index]->metadata;\
469 break; /* handled separately below */ \
470 default: av_assert0(0);\
473 SET_DICT(type_in, meta_in, ic, idx_in);
474 SET_DICT(type_out, meta_out, oc, idx_out);
476 /* for input streams choose first matching stream */
477 if (type_in == 's') {
478 for (i = 0; i < ic->nb_streams; i++) {
479 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
480 meta_in = &ic->streams[i]->metadata;
486 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
491 if (type_out == 's') {
492 for (i = 0; i < oc->nb_streams; i++) {
493 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
494 meta_out = &oc->streams[i]->metadata;
495 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
500 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
505 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
507 OptionsContext *o = optctx;
509 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
510 struct tm time = *gmtime((time_t*)&recording_timestamp);
511 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
512 parse_option(o, "metadata", buf, options);
514 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
515 "tag instead.\n", opt);
519 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
521 const AVCodecDescriptor *desc;
522 const char *codec_string = encoder ? "encoder" : "decoder";
526 avcodec_find_encoder_by_name(name) :
527 avcodec_find_decoder_by_name(name);
529 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
530 codec = encoder ? avcodec_find_encoder(desc->id) :
531 avcodec_find_decoder(desc->id);
533 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
534 codec_string, codec->name, desc->name);
538 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
541 if (codec->type != type) {
542 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
548 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
550 char *codec_name = NULL;
552 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
554 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
555 st->codec->codec_id = codec->id;
558 return avcodec_find_decoder(st->codec->codec_id);
561 /* Add all the streams from the given input file to the global
562 * list of input streams. */
563 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
567 for (i = 0; i < ic->nb_streams; i++) {
568 AVStream *st = ic->streams[i];
569 AVCodecContext *dec = st->codec;
570 InputStream *ist = av_mallocz(sizeof(*ist));
571 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
572 char *codec_tag = NULL;
574 char *discard_str = NULL;
575 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
580 GROW_ARRAY(input_streams, nb_input_streams);
581 input_streams[nb_input_streams - 1] = ist;
584 ist->file_index = nb_input_files;
586 st->discard = AVDISCARD_ALL;
589 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
591 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
593 uint32_t tag = strtol(codec_tag, &next, 0);
595 tag = AV_RL32(codec_tag);
596 st->codec->codec_tag = tag;
599 ist->dec = choose_decoder(o, ic, st);
600 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
602 ist->reinit_filters = -1;
603 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
605 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
606 ist->user_set_discard = AVDISCARD_NONE;
607 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
608 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
613 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
615 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
617 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
621 ret = avcodec_copy_context(ist->dec_ctx, dec);
623 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
627 switch (dec->codec_type) {
628 case AVMEDIA_TYPE_VIDEO:
630 ist->dec = avcodec_find_decoder(dec->codec_id);
631 if (av_codec_get_lowres(dec)) {
632 dec->flags |= CODEC_FLAG_EMU_EDGE;
635 ist->resample_height = ist->dec_ctx->height;
636 ist->resample_width = ist->dec_ctx->width;
637 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
639 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
640 if (framerate && av_parse_video_rate(&ist->framerate,
642 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
647 ist->top_field_first = -1;
648 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
650 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
652 if (!strcmp(hwaccel, "none"))
653 ist->hwaccel_id = HWACCEL_NONE;
654 else if (!strcmp(hwaccel, "auto"))
655 ist->hwaccel_id = HWACCEL_AUTO;
658 for (i = 0; hwaccels[i].name; i++) {
659 if (!strcmp(hwaccels[i].name, hwaccel)) {
660 ist->hwaccel_id = hwaccels[i].id;
665 if (!ist->hwaccel_id) {
666 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
668 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
669 for (i = 0; hwaccels[i].name; i++)
670 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
671 av_log(NULL, AV_LOG_FATAL, "\n");
677 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
678 if (hwaccel_device) {
679 ist->hwaccel_device = av_strdup(hwaccel_device);
680 if (!ist->hwaccel_device)
683 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
686 case AVMEDIA_TYPE_AUDIO:
687 ist->guess_layout_max = INT_MAX;
688 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
689 guess_input_channel_layout(ist);
691 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
692 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
693 ist->resample_channels = ist->dec_ctx->channels;
694 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
697 case AVMEDIA_TYPE_DATA:
698 case AVMEDIA_TYPE_SUBTITLE: {
699 char *canvas_size = NULL;
701 ist->dec = avcodec_find_decoder(dec->codec_id);
702 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
703 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
705 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
706 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
711 case AVMEDIA_TYPE_ATTACHMENT:
712 case AVMEDIA_TYPE_UNKNOWN:
720 static void assert_file_overwrite(const char *filename)
722 if (file_overwrite && no_file_overwrite) {
723 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
727 if (!file_overwrite) {
728 const char *proto_name = avio_find_protocol_name(filename);
729 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
730 if (stdin_interaction && !no_file_overwrite) {
731 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
734 signal(SIGINT, SIG_DFL);
736 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
742 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
749 static void dump_attachment(AVStream *st, const char *filename)
752 AVIOContext *out = NULL;
753 AVDictionaryEntry *e;
755 if (!st->codec->extradata_size) {
756 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
757 nb_input_files - 1, st->index);
760 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
763 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
764 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
768 assert_file_overwrite(filename);
770 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
771 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
776 avio_write(out, st->codec->extradata, st->codec->extradata_size);
781 static int open_input_file(OptionsContext *o, const char *filename)
785 AVInputFormat *file_iformat = NULL;
789 AVDictionary *unused_opts = NULL;
790 AVDictionaryEntry *e = NULL;
791 int orig_nb_streams; // number of streams before avformat_find_stream_info
792 char * video_codec_name = NULL;
793 char * audio_codec_name = NULL;
794 char *subtitle_codec_name = NULL;
797 if (!(file_iformat = av_find_input_format(o->format))) {
798 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
803 if (!strcmp(filename, "-"))
806 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
807 strcmp(filename, "/dev/stdin");
809 /* get default parameters from command line */
810 ic = avformat_alloc_context();
812 print_error(filename, AVERROR(ENOMEM));
815 if (o->nb_audio_sample_rate) {
816 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
818 if (o->nb_audio_channels) {
819 /* because we set audio_channels based on both the "ac" and
820 * "channel_layout" options, we need to check that the specified
821 * demuxer actually has the "channels" option before setting it */
822 if (file_iformat && file_iformat->priv_class &&
823 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
824 AV_OPT_SEARCH_FAKE_OBJ)) {
825 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
828 if (o->nb_frame_rates) {
829 /* set the format-level framerate option;
830 * this is important for video grabbers, e.g. x11 */
831 if (file_iformat && file_iformat->priv_class &&
832 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
833 AV_OPT_SEARCH_FAKE_OBJ)) {
834 av_dict_set(&o->g->format_opts, "framerate",
835 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
838 if (o->nb_frame_sizes) {
839 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
841 if (o->nb_frame_pix_fmts)
842 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
844 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
845 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
846 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
848 ic->video_codec_id = video_codec_name ?
849 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
850 ic->audio_codec_id = audio_codec_name ?
851 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
852 ic->subtitle_codec_id= subtitle_codec_name ?
853 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
855 if (video_codec_name)
856 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
857 if (audio_codec_name)
858 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
859 if (subtitle_codec_name)
860 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
862 ic->flags |= AVFMT_FLAG_NONBLOCK;
863 ic->interrupt_callback = int_cb;
865 /* open the input file with generic avformat function */
866 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
868 print_error(filename, err);
871 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
872 assert_avoptions(o->g->format_opts);
874 /* apply forced codec ids */
875 for (i = 0; i < ic->nb_streams; i++)
876 choose_decoder(o, ic, ic->streams[i]);
878 /* Set AVCodecContext options for avformat_find_stream_info */
879 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
880 orig_nb_streams = ic->nb_streams;
882 /* If not enough info to get the stream parameters, we decode the
883 first frames to get it. (used in mpeg case for example) */
884 ret = avformat_find_stream_info(ic, opts);
886 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
887 if (ic->nb_streams == 0) {
888 avformat_close_input(&ic);
893 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
894 /* add the stream start time */
895 if (ic->start_time != AV_NOPTS_VALUE)
896 timestamp += ic->start_time;
898 /* if seeking requested, we execute it */
899 if (o->start_time != AV_NOPTS_VALUE) {
900 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
902 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
903 filename, (double)timestamp / AV_TIME_BASE);
907 /* update the current parameters so that they match the one of the input stream */
908 add_input_streams(o, ic);
910 /* dump the file content */
911 av_dump_format(ic, nb_input_files, filename, 0);
913 GROW_ARRAY(input_files, nb_input_files);
914 f = av_mallocz(sizeof(*f));
917 input_files[nb_input_files - 1] = f;
920 f->ist_index = nb_input_streams - ic->nb_streams;
921 f->start_time = o->start_time;
922 f->recording_time = o->recording_time;
923 f->input_ts_offset = o->input_ts_offset;
924 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
925 f->nb_streams = ic->nb_streams;
926 f->rate_emu = o->rate_emu;
927 f->accurate_seek = o->accurate_seek;
929 /* check if all codec options have been used */
930 unused_opts = strip_specifiers(o->g->codec_opts);
931 for (i = f->ist_index; i < nb_input_streams; i++) {
933 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
934 AV_DICT_IGNORE_SUFFIX)))
935 av_dict_set(&unused_opts, e->key, NULL, 0);
939 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
940 const AVClass *class = avcodec_get_class();
941 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
942 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
943 const AVClass *fclass = avformat_get_class();
944 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
945 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
946 if (!option || foption)
950 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
951 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
952 "input file #%d (%s) is not a decoding option.\n", e->key,
953 option->help ? option->help : "", nb_input_files - 1,
958 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
959 "input file #%d (%s) has not been used for any stream. The most "
960 "likely reason is either wrong type (e.g. a video option with "
961 "no video streams) or that it is a private option of some decoder "
962 "which was not actually used for any stream.\n", e->key,
963 option->help ? option->help : "", nb_input_files - 1, filename);
965 av_dict_free(&unused_opts);
967 for (i = 0; i < o->nb_dump_attachment; i++) {
970 for (j = 0; j < ic->nb_streams; j++) {
971 AVStream *st = ic->streams[j];
973 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
974 dump_attachment(st, o->dump_attachment[i].u.str);
978 for (i = 0; i < orig_nb_streams; i++)
979 av_dict_free(&opts[i]);
985 static uint8_t *get_line(AVIOContext *s)
991 if (avio_open_dyn_buf(&line) < 0) {
992 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
996 while ((c = avio_r8(s)) && c != '\n')
999 avio_close_dyn_buf(line, &buf);
1004 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1007 char filename[1000];
1008 const char *base[3] = { getenv("AVCONV_DATADIR"),
1013 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1017 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1018 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1019 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1022 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1023 i != 1 ? "" : "/.avconv", preset_name);
1024 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1030 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1032 char *codec_name = NULL;
1034 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1036 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1037 NULL, ost->st->codec->codec_type);
1038 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1039 } else if (!strcmp(codec_name, "copy"))
1040 ost->stream_copy = 1;
1042 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1043 ost->st->codec->codec_id = ost->enc->id;
1047 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1050 AVStream *st = avformat_new_stream(oc, NULL);
1051 int idx = oc->nb_streams - 1, ret = 0;
1052 char *bsf = NULL, *next, *codec_tag = NULL;
1053 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1058 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1062 if (oc->nb_streams - 1 < o->nb_streamid_map)
1063 st->id = o->streamid_map[oc->nb_streams - 1];
1065 GROW_ARRAY(output_streams, nb_output_streams);
1066 if (!(ost = av_mallocz(sizeof(*ost))))
1068 output_streams[nb_output_streams - 1] = ost;
1070 ost->file_index = nb_output_files - 1;
1073 st->codec->codec_type = type;
1074 choose_encoder(o, oc, ost);
1076 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1077 if (!ost->enc_ctx) {
1078 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1081 ost->enc_ctx->codec_type = type;
1084 AVIOContext *s = NULL;
1085 char *buf = NULL, *arg = NULL, *preset = NULL;
1087 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1089 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1090 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1093 if (!buf[0] || buf[0] == '#') {
1097 if (!(arg = strchr(buf, '='))) {
1098 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1102 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1104 } while (!s->eof_reached);
1108 av_log(NULL, AV_LOG_FATAL,
1109 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1110 preset, ost->file_index, ost->index);
1114 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1117 ost->max_frames = INT64_MAX;
1118 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1119 for (i = 0; i<o->nb_max_frames; i++) {
1120 char *p = o->max_frames[i].specifier;
1121 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1122 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1127 ost->copy_prior_start = -1;
1128 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1130 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1132 if (next = strchr(bsf, ','))
1134 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1135 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1139 bsfc_prev->next = bsfc;
1141 ost->bitstream_filters = bsfc;
1147 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1149 uint32_t tag = strtol(codec_tag, &next, 0);
1151 tag = AV_RL32(codec_tag);
1152 ost->enc_ctx->codec_tag = tag;
1155 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1157 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1158 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1161 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1162 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1164 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1166 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1167 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1168 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1170 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1172 ost->source_index = source_index;
1173 if (source_index >= 0) {
1174 ost->sync_ist = input_streams[source_index];
1175 input_streams[source_index]->discard = 0;
1176 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1178 ost->last_mux_dts = AV_NOPTS_VALUE;
1183 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1186 const char *p = str;
1193 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1200 /* read file contents into a string */
1201 static uint8_t *read_file(const char *filename)
1203 AVIOContext *pb = NULL;
1204 AVIOContext *dyn_buf = NULL;
1205 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1206 uint8_t buf[1024], *str;
1209 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1213 ret = avio_open_dyn_buf(&dyn_buf);
1218 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1219 avio_write(dyn_buf, buf, ret);
1220 avio_w8(dyn_buf, 0);
1223 ret = avio_close_dyn_buf(dyn_buf, &str);
1229 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1232 AVStream *st = ost->st;
1234 if (ost->filters_script && ost->filters) {
1235 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1236 "output stream #%d:%d.\n", nb_output_files, st->index);
1240 if (ost->filters_script)
1241 return read_file(ost->filters_script);
1242 else if (ost->filters)
1243 return av_strdup(ost->filters);
1245 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1249 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1250 const OutputStream *ost, enum AVMediaType type)
1252 if (ost->filters_script || ost->filters) {
1253 av_log(NULL, AV_LOG_ERROR,
1254 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1255 "Filtering and streamcopy cannot be used together.\n",
1256 ost->filters ? "Filtergraph" : "Filtergraph script",
1257 ost->filters ? ost->filters : ost->filters_script,
1258 av_get_media_type_string(type), ost->file_index, ost->index);
1263 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1267 AVCodecContext *video_enc;
1268 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1270 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1272 video_enc = ost->enc_ctx;
1274 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1275 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1276 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1280 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1281 if (frame_aspect_ratio) {
1283 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1284 q.num <= 0 || q.den <= 0) {
1285 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1288 ost->frame_aspect_ratio = q;
1291 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1292 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1294 if (!ost->stream_copy) {
1295 const char *p = NULL;
1296 char *frame_size = NULL;
1297 char *frame_pix_fmt = NULL;
1298 char *intra_matrix = NULL, *inter_matrix = NULL;
1299 char *chroma_intra_matrix = NULL;
1303 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1304 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1305 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1309 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1310 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1311 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1312 ost->keep_pix_fmt = 1;
1313 if (!*++frame_pix_fmt)
1314 frame_pix_fmt = NULL;
1316 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1317 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1320 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1323 video_enc->gop_size = 0;
1324 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1326 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1327 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1330 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1332 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1333 if (chroma_intra_matrix) {
1334 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1336 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1339 av_codec_set_chroma_intra_matrix(video_enc, p);
1340 parse_matrix_coeffs(p, chroma_intra_matrix);
1342 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1344 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1345 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1348 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1351 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1352 for (i = 0; p; i++) {
1354 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1356 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1359 /* FIXME realloc failure */
1360 video_enc->rc_override =
1361 av_realloc(video_enc->rc_override,
1362 sizeof(RcOverride) * (i + 1));
1363 video_enc->rc_override[i].start_frame = start;
1364 video_enc->rc_override[i].end_frame = end;
1366 video_enc->rc_override[i].qscale = q;
1367 video_enc->rc_override[i].quality_factor = 1.0;
1370 video_enc->rc_override[i].qscale = 0;
1371 video_enc->rc_override[i].quality_factor = -q/100.0;
1376 video_enc->rc_override_count = i;
1379 video_enc->flags|= CODEC_FLAG_PSNR;
1382 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1385 video_enc->flags |= CODEC_FLAG_PASS1;
1386 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1389 video_enc->flags |= CODEC_FLAG_PASS2;
1390 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1394 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1395 if (ost->logfile_prefix &&
1396 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1399 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1400 if (ost->forced_keyframes)
1401 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1403 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1405 ost->top_field_first = -1;
1406 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1409 ost->avfilter = get_ost_filters(o, oc, ost);
1413 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1416 if (ost->stream_copy)
1417 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1422 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1427 AVCodecContext *audio_enc;
1429 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1432 audio_enc = ost->enc_ctx;
1433 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1435 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1436 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1438 if (!ost->stream_copy) {
1439 char *sample_fmt = NULL;
1441 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1443 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1445 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1446 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1450 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1452 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1453 ost->apad = av_strdup(ost->apad);
1455 ost->avfilter = get_ost_filters(o, oc, ost);
1459 /* check for channel mapping for this audio stream */
1460 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1461 AudioChannelMap *map = &o->audio_channel_maps[n];
1462 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1463 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1466 if (map->channel_idx == -1) {
1468 } else if (ost->source_index < 0) {
1469 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1470 ost->file_index, ost->st->index);
1473 ist = input_streams[ost->source_index];
1476 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1477 if (av_reallocp_array(&ost->audio_channels_map,
1478 ost->audio_channels_mapped + 1,
1479 sizeof(*ost->audio_channels_map)
1483 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1489 if (ost->stream_copy)
1490 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1495 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1499 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1500 if (!ost->stream_copy) {
1501 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1508 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1510 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1511 ost->stream_copy = 1;
1516 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1520 AVCodecContext *subtitle_enc;
1522 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1524 subtitle_enc = ost->enc_ctx;
1526 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1528 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1530 if (!ost->stream_copy) {
1531 char *frame_size = NULL;
1533 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1534 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1535 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1543 /* arg format is "output-stream-index:streamid-value". */
1544 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1546 OptionsContext *o = optctx;
1551 av_strlcpy(idx_str, arg, sizeof(idx_str));
1552 p = strchr(idx_str, ':');
1554 av_log(NULL, AV_LOG_FATAL,
1555 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1560 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1561 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1562 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1566 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1568 AVFormatContext *is = ifile->ctx;
1569 AVFormatContext *os = ofile->ctx;
1573 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1575 return AVERROR(ENOMEM);
1578 for (i = 0; i < is->nb_chapters; i++) {
1579 AVChapter *in_ch = is->chapters[i], *out_ch;
1580 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1581 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1582 AV_TIME_BASE_Q, in_ch->time_base);
1583 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1584 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1587 if (in_ch->end < ts_off)
1589 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1592 out_ch = av_mallocz(sizeof(AVChapter));
1594 return AVERROR(ENOMEM);
1596 out_ch->id = in_ch->id;
1597 out_ch->time_base = in_ch->time_base;
1598 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1599 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1602 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1604 os->chapters[os->nb_chapters++] = out_ch;
1609 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1612 AVFormatContext *ic = avformat_alloc_context();
1614 ic->interrupt_callback = int_cb;
1615 err = avformat_open_input(&ic, filename, NULL, NULL);
1618 /* copy stream format */
1619 for(i=0;i<ic->nb_streams;i++) {
1623 AVCodecContext *avctx;
1625 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1626 ost = new_output_stream(o, s, codec->type, -1);
1631 // FIXME: a more elegant solution is needed
1632 memcpy(st, ic->streams[i], sizeof(AVStream));
1634 st->info = av_malloc(sizeof(*st->info));
1635 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1637 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1639 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1640 choose_sample_fmt(st, codec);
1641 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1642 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1643 avcodec_copy_context(ost->enc_ctx, st->codec);
1646 avformat_close_input(&ic);
1650 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1651 AVFormatContext *oc)
1655 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1656 ofilter->out_tmp->pad_idx)) {
1657 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1658 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1660 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1665 ost->source_index = -1;
1666 ost->filter = ofilter;
1670 if (ost->stream_copy) {
1671 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1672 "which is fed from a complex filtergraph. Filtering and streamcopy "
1673 "cannot be used together.\n", ost->file_index, ost->index);
1677 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1678 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1679 av_log(NULL, AV_LOG_ERROR,
1680 "%s '%s' was specified through the %s option "
1681 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1682 "%s and -filter_complex cannot be used together for the same stream.\n",
1683 ost->filters ? "Filtergraph" : "Filtergraph script",
1684 ost->filters ? ost->filters : ost->filters_script,
1685 opt, ost->file_index, ost->index, opt);
1689 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1690 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1693 avfilter_inout_free(&ofilter->out_tmp);
1696 static int configure_complex_filters(void)
1700 for (i = 0; i < nb_filtergraphs; i++)
1701 if (!filtergraphs[i]->graph &&
1702 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1707 static int open_output_file(OptionsContext *o, const char *filename)
1709 AVFormatContext *oc;
1711 AVOutputFormat *file_oformat;
1715 AVDictionary *unused_opts = NULL;
1716 AVDictionaryEntry *e = NULL;
1718 if (configure_complex_filters() < 0) {
1719 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1723 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1724 o->stop_time = INT64_MAX;
1725 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1728 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1729 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1730 if (o->stop_time <= start_time) {
1731 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1732 o->stop_time = INT64_MAX;
1734 o->recording_time = o->stop_time - start_time;
1738 GROW_ARRAY(output_files, nb_output_files);
1739 of = av_mallocz(sizeof(*of));
1742 output_files[nb_output_files - 1] = of;
1744 of->ost_index = nb_output_streams;
1745 of->recording_time = o->recording_time;
1746 of->start_time = o->start_time;
1747 of->limit_filesize = o->limit_filesize;
1748 of->shortest = o->shortest;
1749 av_dict_copy(&of->opts, o->g->format_opts, 0);
1751 if (!strcmp(filename, "-"))
1754 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1756 print_error(filename, err);
1761 if (o->recording_time != INT64_MAX)
1762 oc->duration = o->recording_time;
1764 file_oformat= oc->oformat;
1765 oc->interrupt_callback = int_cb;
1767 /* create streams for all unlabeled output pads */
1768 for (i = 0; i < nb_filtergraphs; i++) {
1769 FilterGraph *fg = filtergraphs[i];
1770 for (j = 0; j < fg->nb_outputs; j++) {
1771 OutputFilter *ofilter = fg->outputs[j];
1773 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1776 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1777 ofilter->out_tmp->pad_idx)) {
1778 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1779 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1780 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1782 init_output_filter(ofilter, o, oc);
1786 /* ffserver seeking with date=... needs a date reference */
1787 if (!strcmp(file_oformat->name, "ffm") &&
1788 av_strstart(filename, "http:", NULL)) {
1789 int err = parse_option(o, "metadata", "creation_time=now", options);
1791 print_error(filename, err);
1796 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1797 av_strstart(filename, "http:", NULL)) {
1799 /* special case for files sent to ffserver: we get the stream
1800 parameters from ffserver */
1801 int err = read_ffserver_streams(o, oc, filename);
1803 print_error(filename, err);
1806 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1807 ost = output_streams[j];
1808 for (i = 0; i < nb_input_streams; i++) {
1809 ist = input_streams[i];
1810 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1812 ost->source_index= i;
1813 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1814 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1816 ist->st->discard = ist->user_set_discard;
1821 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));
1825 } else if (!o->nb_stream_maps) {
1826 char *subtitle_codec_name = NULL;
1827 /* pick the "best" stream of each type */
1829 /* video: highest resolution */
1830 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1831 int area = 0, idx = -1;
1832 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1833 for (i = 0; i < nb_input_streams; i++) {
1835 ist = input_streams[i];
1836 new_area = ist->st->codec->width * ist->st->codec->height;
1837 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1839 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1841 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1848 new_video_stream(o, oc, idx);
1851 /* audio: most channels */
1852 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1853 int channels = 0, idx = -1;
1854 for (i = 0; i < nb_input_streams; i++) {
1855 ist = input_streams[i];
1856 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1857 ist->st->codec->channels > channels) {
1858 channels = ist->st->codec->channels;
1863 new_audio_stream(o, oc, idx);
1866 /* subtitles: pick first */
1867 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1868 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1869 for (i = 0; i < nb_input_streams; i++)
1870 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1871 AVCodecDescriptor const *input_descriptor =
1872 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1873 AVCodecDescriptor const *output_descriptor = NULL;
1874 AVCodec const *output_codec =
1875 avcodec_find_encoder(oc->oformat->subtitle_codec);
1876 int input_props = 0, output_props = 0;
1878 output_descriptor = avcodec_descriptor_get(output_codec->id);
1879 if (input_descriptor)
1880 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1881 if (output_descriptor)
1882 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1883 if (subtitle_codec_name ||
1884 input_props & output_props ||
1885 // Map dvb teletext which has neither property to any output subtitle encoder
1886 input_descriptor && output_descriptor &&
1887 (!input_descriptor->props ||
1888 !output_descriptor->props)) {
1889 new_subtitle_stream(o, oc, i);
1894 /* do something with data? */
1896 for (i = 0; i < o->nb_stream_maps; i++) {
1897 StreamMap *map = &o->stream_maps[i];
1902 if (map->linklabel) {
1904 OutputFilter *ofilter = NULL;
1907 for (j = 0; j < nb_filtergraphs; j++) {
1908 fg = filtergraphs[j];
1909 for (k = 0; k < fg->nb_outputs; k++) {
1910 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1911 if (out && !strcmp(out->name, map->linklabel)) {
1912 ofilter = fg->outputs[k];
1919 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1920 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1923 init_output_filter(ofilter, o, oc);
1925 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1927 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1928 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1930 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1932 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1934 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1937 switch (ist->st->codec->codec_type) {
1938 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1939 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1940 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1941 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1942 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1944 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1945 map->file_index, map->stream_index);
1952 /* handle attached files */
1953 for (i = 0; i < o->nb_attachments; i++) {
1955 uint8_t *attachment;
1959 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1960 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1964 if ((len = avio_size(pb)) <= 0) {
1965 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1969 if (!(attachment = av_malloc(len))) {
1970 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1974 avio_read(pb, attachment, len);
1976 ost = new_attachment_stream(o, oc, -1);
1977 ost->stream_copy = 0;
1978 ost->attachment_filename = o->attachments[i];
1980 ost->enc_ctx->extradata = attachment;
1981 ost->enc_ctx->extradata_size = len;
1983 p = strrchr(o->attachments[i], '/');
1984 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1988 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1989 AVDictionaryEntry *e;
1990 ost = output_streams[i];
1992 if ((ost->stream_copy || ost->attachment_filename)
1993 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1994 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1995 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1999 /* check if all codec options have been used */
2000 unused_opts = strip_specifiers(o->g->codec_opts);
2001 for (i = of->ost_index; i < nb_output_streams; i++) {
2003 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2004 AV_DICT_IGNORE_SUFFIX)))
2005 av_dict_set(&unused_opts, e->key, NULL, 0);
2009 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2010 const AVClass *class = avcodec_get_class();
2011 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2012 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2013 const AVClass *fclass = avformat_get_class();
2014 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2015 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2016 if (!option || foption)
2020 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2021 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2022 "output file #%d (%s) is not an encoding option.\n", e->key,
2023 option->help ? option->help : "", nb_output_files - 1,
2028 // gop_timecode is injected by generic code but not always used
2029 if (!strcmp(e->key, "gop_timecode"))
2032 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2033 "output file #%d (%s) has not been used for any stream. The most "
2034 "likely reason is either wrong type (e.g. a video option with "
2035 "no video streams) or that it is a private option of some encoder "
2036 "which was not actually used for any stream.\n", e->key,
2037 option->help ? option->help : "", nb_output_files - 1, filename);
2039 av_dict_free(&unused_opts);
2041 /* check filename in case of an image number is expected */
2042 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2043 if (!av_filename_number_test(oc->filename)) {
2044 print_error(oc->filename, AVERROR(EINVAL));
2049 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2050 /* test if it already exists to avoid losing precious files */
2051 assert_file_overwrite(filename);
2054 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2055 &oc->interrupt_callback,
2057 print_error(filename, err);
2060 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2061 assert_file_overwrite(filename);
2063 if (o->mux_preload) {
2064 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2066 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2069 for (i = 0; i < o->nb_metadata_map; i++) {
2071 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2073 if (in_file_index >= nb_input_files) {
2074 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2077 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2078 in_file_index >= 0 ?
2079 input_files[in_file_index]->ctx : NULL, o);
2083 if (o->chapters_input_file >= nb_input_files) {
2084 if (o->chapters_input_file == INT_MAX) {
2085 /* copy chapters from the first input file that has them*/
2086 o->chapters_input_file = -1;
2087 for (i = 0; i < nb_input_files; i++)
2088 if (input_files[i]->ctx->nb_chapters) {
2089 o->chapters_input_file = i;
2093 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2094 o->chapters_input_file);
2098 if (o->chapters_input_file >= 0)
2099 copy_chapters(input_files[o->chapters_input_file], of,
2100 !o->metadata_chapters_manual);
2102 /* copy global metadata by default */
2103 if (!o->metadata_global_manual && nb_input_files){
2104 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2105 AV_DICT_DONT_OVERWRITE);
2106 if(o->recording_time != INT64_MAX)
2107 av_dict_set(&oc->metadata, "duration", NULL, 0);
2108 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2110 if (!o->metadata_streams_manual)
2111 for (i = of->ost_index; i < nb_output_streams; i++) {
2113 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2115 ist = input_streams[output_streams[i]->source_index];
2116 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2117 if (!output_streams[i]->stream_copy)
2118 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2121 /* process manually set metadata */
2122 for (i = 0; i < o->nb_metadata; i++) {
2125 const char *stream_spec;
2126 int index = 0, j, ret = 0;
2128 val = strchr(o->metadata[i].u.str, '=');
2130 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2131 o->metadata[i].u.str);
2136 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2138 for (j = 0; j < oc->nb_streams; j++) {
2139 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2140 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2151 if (index < 0 || index >= oc->nb_chapters) {
2152 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2155 m = &oc->chapters[index]->metadata;
2158 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2161 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2168 static int opt_target(void *optctx, const char *opt, const char *arg)
2170 OptionsContext *o = optctx;
2171 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2172 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2174 if (!strncmp(arg, "pal-", 4)) {
2177 } else if (!strncmp(arg, "ntsc-", 5)) {
2180 } else if (!strncmp(arg, "film-", 5)) {
2184 /* Try to determine PAL/NTSC by peeking in the input files */
2185 if (nb_input_files) {
2187 for (j = 0; j < nb_input_files; j++) {
2188 for (i = 0; i < input_files[j]->nb_streams; i++) {
2189 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2190 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2193 fr = c->time_base.den * 1000 / c->time_base.num;
2197 } else if ((fr == 29970) || (fr == 23976)) {
2202 if (norm != UNKNOWN)
2206 if (norm != UNKNOWN)
2207 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2210 if (norm == UNKNOWN) {
2211 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2212 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2213 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2217 if (!strcmp(arg, "vcd")) {
2218 opt_video_codec(o, "c:v", "mpeg1video");
2219 opt_audio_codec(o, "c:a", "mp2");
2220 parse_option(o, "f", "vcd", options);
2222 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2223 parse_option(o, "r", frame_rates[norm], options);
2224 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2226 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2227 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2228 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2229 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2231 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2232 parse_option(o, "ar", "44100", options);
2233 parse_option(o, "ac", "2", options);
2235 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2236 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2238 /* We have to offset the PTS, so that it is consistent with the SCR.
2239 SCR starts at 36000, but the first two packs contain only padding
2240 and the first pack from the other stream, respectively, may also have
2241 been written before.
2242 So the real data starts at SCR 36000+3*1200. */
2243 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2244 } else if (!strcmp(arg, "svcd")) {
2246 opt_video_codec(o, "c:v", "mpeg2video");
2247 opt_audio_codec(o, "c:a", "mp2");
2248 parse_option(o, "f", "svcd", options);
2250 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2251 parse_option(o, "r", frame_rates[norm], options);
2252 parse_option(o, "pix_fmt", "yuv420p", options);
2253 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2255 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2256 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2257 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2258 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2259 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2261 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2262 parse_option(o, "ar", "44100", options);
2264 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2266 } else if (!strcmp(arg, "dvd")) {
2268 opt_video_codec(o, "c:v", "mpeg2video");
2269 opt_audio_codec(o, "c:a", "ac3");
2270 parse_option(o, "f", "dvd", options);
2272 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2273 parse_option(o, "r", frame_rates[norm], options);
2274 parse_option(o, "pix_fmt", "yuv420p", options);
2275 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2277 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2278 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2279 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2280 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2282 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2283 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2285 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2286 parse_option(o, "ar", "48000", options);
2288 } else if (!strncmp(arg, "dv", 2)) {
2290 parse_option(o, "f", "dv", options);
2292 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2293 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2294 norm == PAL ? "yuv420p" : "yuv411p", options);
2295 parse_option(o, "r", frame_rates[norm], options);
2297 parse_option(o, "ar", "48000", options);
2298 parse_option(o, "ac", "2", options);
2301 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2302 return AVERROR(EINVAL);
2307 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2309 av_free (vstats_filename);
2310 vstats_filename = av_strdup (arg);
2314 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2317 time_t today2 = time(NULL);
2318 struct tm *today = localtime(&today2);
2320 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2322 return opt_vstats_file(NULL, opt, filename);
2325 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2327 OptionsContext *o = optctx;
2328 return parse_option(o, "frames:v", arg, options);
2331 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2333 OptionsContext *o = optctx;
2334 return parse_option(o, "frames:a", arg, options);
2337 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2339 OptionsContext *o = optctx;
2340 return parse_option(o, "frames:d", arg, options);
2343 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2346 AVDictionary *cbak = codec_opts;
2347 AVDictionary *fbak = format_opts;
2351 ret = opt_default(NULL, opt, arg);
2353 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2354 av_dict_copy(&o->g->format_opts, format_opts, 0);
2355 av_dict_free(&codec_opts);
2356 av_dict_free(&format_opts);
2363 static int opt_preset(void *optctx, const char *opt, const char *arg)
2365 OptionsContext *o = optctx;
2367 char filename[1000], line[1000], tmp_line[1000];
2368 const char *codec_name = NULL;
2372 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2374 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2375 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2376 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2378 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2382 while (fgets(line, sizeof(line), f)) {
2383 char *key = tmp_line, *value, *endptr;
2385 if (strcspn(line, "#\n\r") == 0)
2387 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2388 if (!av_strtok(key, "=", &value) ||
2389 !av_strtok(value, "\r\n", &endptr)) {
2390 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2393 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2395 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2396 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2397 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2398 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2399 else if (opt_default_new(o, key, value) < 0) {
2400 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2401 filename, line, key, value);
2411 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2413 OptionsContext *o = optctx;
2414 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2415 int ret = parse_option(o, s, arg, options);
2420 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2422 OptionsContext *o = optctx;
2424 if(!strcmp(opt, "ab")){
2425 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2427 } else if(!strcmp(opt, "b")){
2428 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2429 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2432 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2436 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2438 OptionsContext *o = optctx;
2441 if(!strcmp(opt, "qscale")){
2442 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2443 return parse_option(o, "q:v", arg, options);
2445 s = av_asprintf("q%s", opt + 6);
2446 ret = parse_option(o, s, arg, options);
2451 static int opt_profile(void *optctx, const char *opt, const char *arg)
2453 OptionsContext *o = optctx;
2454 if(!strcmp(opt, "profile")){
2455 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2456 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2459 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2463 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2465 OptionsContext *o = optctx;
2466 return parse_option(o, "filter:v", arg, options);
2469 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2471 OptionsContext *o = optctx;
2472 return parse_option(o, "filter:a", arg, options);
2475 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2477 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2478 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2479 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2480 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2482 if (video_sync_method == VSYNC_AUTO)
2483 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2487 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2489 OptionsContext *o = optctx;
2490 char *tcr = av_asprintf("timecode=%s", arg);
2491 int ret = parse_option(o, "metadata:g", tcr, options);
2493 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2498 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2500 OptionsContext *o = optctx;
2501 char layout_str[32];
2504 int ret, channels, ac_str_size;
2507 layout = av_get_channel_layout(arg);
2509 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2510 return AVERROR(EINVAL);
2512 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2513 ret = opt_default_new(o, opt, layout_str);
2517 /* set 'ac' option based on channel layout */
2518 channels = av_get_channel_layout_nb_channels(layout);
2519 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2520 stream_str = strchr(opt, ':');
2521 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2522 ac_str = av_mallocz(ac_str_size);
2524 return AVERROR(ENOMEM);
2525 av_strlcpy(ac_str, "ac", 3);
2527 av_strlcat(ac_str, stream_str, ac_str_size);
2528 ret = parse_option(o, ac_str, layout_str, options);
2534 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2536 OptionsContext *o = optctx;
2537 return parse_option(o, "q:a", arg, options);
2540 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2542 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2543 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2544 return AVERROR(ENOMEM);
2545 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2546 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2547 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2548 return AVERROR(ENOMEM);
2552 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2554 uint8_t *graph_desc = read_file(arg);
2556 return AVERROR(EINVAL);
2558 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2559 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2560 return AVERROR(ENOMEM);
2561 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2562 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2566 void show_help_default(const char *opt, const char *arg)
2568 /* per-file options have at least one of those set */
2569 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2570 int show_advanced = 0, show_avoptions = 0;
2573 if (!strcmp(opt, "long"))
2575 else if (!strcmp(opt, "full"))
2576 show_advanced = show_avoptions = 1;
2578 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2583 printf("Getting help:\n"
2584 " -h -- print basic options\n"
2585 " -h long -- print more options\n"
2586 " -h full -- print all options (including all format and codec specific options, very long)\n"
2587 " See man %s for detailed description of the options.\n"
2588 "\n", program_name);
2590 show_help_options(options, "Print help / information / capabilities:",
2593 show_help_options(options, "Global options (affect whole program "
2594 "instead of just one file:",
2595 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2597 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2598 per_file | OPT_EXIT, 0);
2600 show_help_options(options, "Per-file main options:", 0,
2601 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2602 OPT_EXIT, per_file);
2604 show_help_options(options, "Advanced per-file options:",
2605 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2607 show_help_options(options, "Video options:",
2608 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2610 show_help_options(options, "Advanced Video options:",
2611 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2613 show_help_options(options, "Audio options:",
2614 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2616 show_help_options(options, "Advanced Audio options:",
2617 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2618 show_help_options(options, "Subtitle options:",
2619 OPT_SUBTITLE, 0, 0);
2622 if (show_avoptions) {
2623 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2624 show_help_children(avcodec_get_class(), flags);
2625 show_help_children(avformat_get_class(), flags);
2627 show_help_children(sws_get_class(), flags);
2629 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2630 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2634 void show_usage(void)
2636 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2637 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2638 av_log(NULL, AV_LOG_INFO, "\n");
2646 static const OptionGroupDef groups[] = {
2647 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2648 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2651 static int open_files(OptionGroupList *l, const char *inout,
2652 int (*open_file)(OptionsContext*, const char*))
2656 for (i = 0; i < l->nb_groups; i++) {
2657 OptionGroup *g = &l->groups[i];
2663 ret = parse_optgroup(&o, g);
2665 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2666 "%s.\n", inout, g->arg);
2670 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2671 ret = open_file(&o, g->arg);
2674 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2678 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2684 int ffmpeg_parse_options(int argc, char **argv)
2686 OptionParseContext octx;
2690 memset(&octx, 0, sizeof(octx));
2692 /* split the commandline into an internal representation */
2693 ret = split_commandline(&octx, argc, argv, options, groups,
2694 FF_ARRAY_ELEMS(groups));
2696 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2700 /* apply global options */
2701 ret = parse_optgroup(NULL, &octx.global_opts);
2703 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2707 /* open input files */
2708 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2710 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2714 /* open output files */
2715 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2717 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2722 uninit_parse_context(&octx);
2724 av_strerror(ret, error, sizeof(error));
2725 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2730 static int opt_progress(void *optctx, const char *opt, const char *arg)
2732 AVIOContext *avio = NULL;
2735 if (!strcmp(arg, "-"))
2737 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2739 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2740 arg, av_err2str(ret));
2743 progress_avio = avio;
2747 #define OFFSET(x) offsetof(OptionsContext, x)
2748 const OptionDef options[] = {
2750 #include "cmdutils_common_opts.h"
2751 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2752 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2753 "force format", "fmt" },
2754 { "y", OPT_BOOL, { &file_overwrite },
2755 "overwrite output files" },
2756 { "n", OPT_BOOL, { &no_file_overwrite },
2757 "never overwrite output files" },
2758 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2759 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2760 "codec name", "codec" },
2761 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2762 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2763 "codec name", "codec" },
2764 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2765 OPT_OUTPUT, { .off = OFFSET(presets) },
2766 "preset name", "preset" },
2767 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2768 OPT_OUTPUT, { .func_arg = opt_map },
2769 "set input stream mapping",
2770 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2771 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2772 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2773 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2774 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2775 "set metadata information of outfile from infile",
2776 "outfile[,metadata]:infile[,metadata]" },
2777 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2778 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2779 "set chapters mapping", "input_file_index" },
2780 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2781 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2782 "record or transcode \"duration\" seconds of audio/video",
2784 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2785 "record or transcode stop time", "time_stop" },
2786 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2787 "set the limit file size in bytes", "limit_size" },
2788 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2789 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2790 "set the start time offset", "time_off" },
2791 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2792 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2793 "enable/disable accurate seeking with -ss" },
2794 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2795 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2796 "set the input ts offset", "time_off" },
2797 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2798 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2799 "set the input ts scale", "scale" },
2800 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2801 "set the recording timestamp ('now' to set the current time)", "time" },
2802 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2803 "add metadata", "string=string" },
2804 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2805 OPT_OUTPUT, { .func_arg = opt_data_frames },
2806 "set the number of data frames to record", "number" },
2807 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2808 "add timings for benchmarking" },
2809 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2810 "add timings for each task" },
2811 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2812 "write program-readable progress information", "url" },
2813 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2814 "enable or disable interaction on standard input" },
2815 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2816 "set max runtime in seconds", "limit" },
2817 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2818 "dump each input packet" },
2819 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2820 "when dumping packets, also dump the payload" },
2821 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2822 OPT_INPUT, { .off = OFFSET(rate_emu) },
2823 "read input at native frame rate", "" },
2824 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2825 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2826 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2827 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2828 "video sync method", "" },
2829 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2830 "audio sync method", "" },
2831 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2832 "audio drift threshold", "threshold" },
2833 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2834 "copy timestamps" },
2835 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2836 "copy input stream time base when stream copying", "mode" },
2837 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2838 OPT_OUTPUT, { .off = OFFSET(shortest) },
2839 "finish encoding within shortest input" },
2840 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2841 OPT_OUTPUT, { .off = OFFSET(apad) },
2843 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2844 "timestamp discontinuity delta threshold", "threshold" },
2845 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2846 "timestamp error delta threshold", "threshold" },
2847 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2848 "exit on error", "error" },
2849 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2850 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2851 "copy initial non-keyframes" },
2852 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2853 "copy or discard frames before start time" },
2854 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2855 "set the number of frames to record", "number" },
2856 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2857 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2858 "force codec tag/fourcc", "fourcc/tag" },
2859 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2860 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2861 "use fixed quality scale (VBR)", "q" },
2862 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2863 OPT_OUTPUT, { .func_arg = opt_qscale },
2864 "use fixed quality scale (VBR)", "q" },
2865 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2866 "set profile", "profile" },
2867 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2868 "set stream filtergraph", "filter_graph" },
2869 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2870 "read stream filtergraph description from a file", "filename" },
2871 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2872 "reinit filtergraph on input parameter changes", "" },
2873 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2874 "create a complex filtergraph", "graph_description" },
2875 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2876 "create a complex filtergraph", "graph_description" },
2877 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2878 "read complex filtergraph description from a file", "filename" },
2879 { "stats", OPT_BOOL, { &print_stats },
2880 "print progress report during encoding", },
2881 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2882 OPT_OUTPUT, { .func_arg = opt_attach },
2883 "add an attachment to the output file", "filename" },
2884 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2885 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2886 "extract an attachment into a file", "filename" },
2887 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2888 "print timestamp debugging info" },
2889 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2890 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2891 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2892 OPT_INPUT, { .off = OFFSET(discard) },
2896 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2897 "set the number of video frames to record", "number" },
2898 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2899 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2900 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2901 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2902 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2903 "set frame size (WxH or abbreviation)", "size" },
2904 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2905 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2906 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2907 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2908 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2909 "set pixel format", "format" },
2910 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2911 "set the number of bits per raw sample", "number" },
2912 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2913 "deprecated use -g 1" },
2914 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2916 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2917 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2918 "rate control override for specific intervals", "override" },
2919 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2920 OPT_OUTPUT, { .func_arg = opt_video_codec },
2921 "force video codec ('copy' to copy stream)", "codec" },
2922 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2924 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2926 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2927 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2928 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2929 "select the pass number (1 to 3)", "n" },
2930 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2931 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2932 "select two pass log file name prefix", "prefix" },
2933 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2934 "this option is deprecated, use the yadif filter instead" },
2935 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2936 "calculate PSNR of compressed frames" },
2937 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2938 "dump video coding statistics to file" },
2939 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2940 "dump video coding statistics to file", "file" },
2941 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2942 "set video filters", "filter_graph" },
2943 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2944 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2945 "specify intra matrix coeffs", "matrix" },
2946 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2947 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2948 "specify inter matrix coeffs", "matrix" },
2949 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2950 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2951 "specify intra matrix coeffs", "matrix" },
2952 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2953 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2954 "top=1/bottom=0/auto=-1 field first", "" },
2955 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2956 OPT_OUTPUT, { .func_arg = opt_old2new },
2957 "force video tag/fourcc", "fourcc/tag" },
2958 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2959 "show QP histogram" },
2960 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2961 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2962 "force the selected framerate, disable the best supported framerate selection" },
2963 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2964 OPT_OUTPUT, { .func_arg = opt_streamid },
2965 "set the value of an outfile streamid", "streamIndex:value" },
2966 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2967 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2968 "force key frames at specified timestamps", "timestamps" },
2969 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2970 "audio bitrate (please use -b:a)", "bitrate" },
2971 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2972 "video bitrate (please use -b:v)", "bitrate" },
2973 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2974 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2975 "use HW accelerated decoding", "hwaccel name" },
2976 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2977 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2978 "select a device for HW acceleration" "devicename" },
2981 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2982 "set the number of audio frames to record", "number" },
2983 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2984 "set audio quality (codec-specific)", "quality", },
2985 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2986 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2987 "set audio sampling rate (in Hz)", "rate" },
2988 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2989 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2990 "set number of audio channels", "channels" },
2991 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2993 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2994 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2995 "force audio codec ('copy' to copy stream)", "codec" },
2996 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2997 OPT_OUTPUT, { .func_arg = opt_old2new },
2998 "force audio tag/fourcc", "fourcc/tag" },
2999 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3000 "change audio volume (256=normal)" , "volume" },
3001 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3002 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3003 "set sample format", "format" },
3004 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3005 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3006 "set channel layout", "layout" },
3007 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3008 "set audio filters", "filter_graph" },
3009 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3010 "set the maximum number of channels to try to guess the channel layout" },
3012 /* subtitle options */
3013 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3014 "disable subtitle" },
3015 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3016 "force subtitle codec ('copy' to copy stream)", "codec" },
3017 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3018 , "force subtitle tag/fourcc", "fourcc/tag" },
3019 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3020 "fix subtitles duration" },
3021 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3022 "set canvas size (WxH or abbreviation)", "size" },
3025 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3026 "deprecated, use -channel", "channel" },
3027 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3028 "deprecated, use -standard", "standard" },
3029 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3032 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3033 "set the maximum demux-decode delay", "seconds" },
3034 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3035 "set the initial demux-decode delay", "seconds" },
3036 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3037 "override the options from ffserver", "" },
3039 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3040 "A comma-separated list of bitstream filters", "bitstream_filters" },
3041 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3042 "deprecated", "audio bitstream_filters" },
3043 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3044 "deprecated", "video bitstream_filters" },
3046 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3047 "set the audio options to the indicated preset", "preset" },
3048 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3049 "set the video options to the indicated preset", "preset" },
3050 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3051 "set the subtitle options to the indicated preset", "preset" },
3052 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3053 "set options from indicated preset file", "filename" },
3054 /* data codec support */
3055 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3056 "force data codec ('copy' to copy stream)", "codec" },
3057 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },