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;
790 AVDictionary *unused_opts = NULL;
791 AVDictionaryEntry *e = NULL;
792 int orig_nb_streams; // number of streams before avformat_find_stream_info
793 char * video_codec_name = NULL;
794 char * audio_codec_name = NULL;
795 char *subtitle_codec_name = NULL;
798 if (!(file_iformat = av_find_input_format(o->format))) {
799 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
804 if (!strcmp(filename, "-"))
807 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
808 strcmp(filename, "/dev/stdin");
810 /* get default parameters from command line */
811 ic = avformat_alloc_context();
813 print_error(filename, AVERROR(ENOMEM));
816 if (o->nb_audio_sample_rate) {
817 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
818 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
820 if (o->nb_audio_channels) {
821 /* because we set audio_channels based on both the "ac" and
822 * "channel_layout" options, we need to check that the specified
823 * demuxer actually has the "channels" option before setting it */
824 if (file_iformat && file_iformat->priv_class &&
825 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
826 AV_OPT_SEARCH_FAKE_OBJ)) {
827 snprintf(buf, sizeof(buf), "%d",
828 o->audio_channels[o->nb_audio_channels - 1].u.i);
829 av_dict_set(&o->g->format_opts, "channels", buf, 0);
832 if (o->nb_frame_rates) {
833 /* set the format-level framerate option;
834 * this is important for video grabbers, e.g. x11 */
835 if (file_iformat && file_iformat->priv_class &&
836 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
837 AV_OPT_SEARCH_FAKE_OBJ)) {
838 av_dict_set(&o->g->format_opts, "framerate",
839 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
842 if (o->nb_frame_sizes) {
843 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
845 if (o->nb_frame_pix_fmts)
846 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
848 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
849 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
850 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
852 ic->video_codec_id = video_codec_name ?
853 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
854 ic->audio_codec_id = audio_codec_name ?
855 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
856 ic->subtitle_codec_id= subtitle_codec_name ?
857 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
859 if (video_codec_name)
860 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
861 if (audio_codec_name)
862 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
863 if (subtitle_codec_name)
864 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
866 ic->flags |= AVFMT_FLAG_NONBLOCK;
867 ic->interrupt_callback = int_cb;
869 /* open the input file with generic avformat function */
870 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
872 print_error(filename, err);
875 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
876 assert_avoptions(o->g->format_opts);
878 /* apply forced codec ids */
879 for (i = 0; i < ic->nb_streams; i++)
880 choose_decoder(o, ic, ic->streams[i]);
882 /* Set AVCodecContext options for avformat_find_stream_info */
883 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
884 orig_nb_streams = ic->nb_streams;
886 /* If not enough info to get the stream parameters, we decode the
887 first frames to get it. (used in mpeg case for example) */
888 ret = avformat_find_stream_info(ic, opts);
890 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
891 if (ic->nb_streams == 0) {
892 avformat_close_input(&ic);
897 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
898 /* add the stream start time */
899 if (ic->start_time != AV_NOPTS_VALUE)
900 timestamp += ic->start_time;
902 /* if seeking requested, we execute it */
903 if (o->start_time != AV_NOPTS_VALUE) {
904 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
906 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
907 filename, (double)timestamp / AV_TIME_BASE);
911 /* update the current parameters so that they match the one of the input stream */
912 add_input_streams(o, ic);
914 /* dump the file content */
915 av_dump_format(ic, nb_input_files, filename, 0);
917 GROW_ARRAY(input_files, nb_input_files);
918 f = av_mallocz(sizeof(*f));
921 input_files[nb_input_files - 1] = f;
924 f->ist_index = nb_input_streams - ic->nb_streams;
925 f->start_time = o->start_time;
926 f->recording_time = o->recording_time;
927 f->input_ts_offset = o->input_ts_offset;
928 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
929 f->nb_streams = ic->nb_streams;
930 f->rate_emu = o->rate_emu;
931 f->accurate_seek = o->accurate_seek;
933 /* check if all codec options have been used */
934 unused_opts = strip_specifiers(o->g->codec_opts);
935 for (i = f->ist_index; i < nb_input_streams; i++) {
937 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
938 AV_DICT_IGNORE_SUFFIX)))
939 av_dict_set(&unused_opts, e->key, NULL, 0);
943 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
944 const AVClass *class = avcodec_get_class();
945 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
946 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
947 const AVClass *fclass = avformat_get_class();
948 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
949 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
950 if (!option || foption)
954 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
955 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
956 "input file #%d (%s) is not a decoding option.\n", e->key,
957 option->help ? option->help : "", nb_input_files - 1,
962 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
963 "input file #%d (%s) has not been used for any stream. The most "
964 "likely reason is either wrong type (e.g. a video option with "
965 "no video streams) or that it is a private option of some decoder "
966 "which was not actually used for any stream.\n", e->key,
967 option->help ? option->help : "", nb_input_files - 1, filename);
969 av_dict_free(&unused_opts);
971 for (i = 0; i < o->nb_dump_attachment; i++) {
974 for (j = 0; j < ic->nb_streams; j++) {
975 AVStream *st = ic->streams[j];
977 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
978 dump_attachment(st, o->dump_attachment[i].u.str);
982 for (i = 0; i < orig_nb_streams; i++)
983 av_dict_free(&opts[i]);
989 static uint8_t *get_line(AVIOContext *s)
995 if (avio_open_dyn_buf(&line) < 0) {
996 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1000 while ((c = avio_r8(s)) && c != '\n')
1003 avio_close_dyn_buf(line, &buf);
1008 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1011 char filename[1000];
1012 const char *base[3] = { getenv("AVCONV_DATADIR"),
1017 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1021 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1022 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1023 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1026 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1027 i != 1 ? "" : "/.avconv", preset_name);
1028 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1034 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1036 char *codec_name = NULL;
1038 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1040 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1041 NULL, ost->st->codec->codec_type);
1042 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1043 } else if (!strcmp(codec_name, "copy"))
1044 ost->stream_copy = 1;
1046 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1047 ost->st->codec->codec_id = ost->enc->id;
1051 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1054 AVStream *st = avformat_new_stream(oc, NULL);
1055 int idx = oc->nb_streams - 1, ret = 0;
1056 char *bsf = NULL, *next, *codec_tag = NULL;
1057 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1062 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1066 if (oc->nb_streams - 1 < o->nb_streamid_map)
1067 st->id = o->streamid_map[oc->nb_streams - 1];
1069 GROW_ARRAY(output_streams, nb_output_streams);
1070 if (!(ost = av_mallocz(sizeof(*ost))))
1072 output_streams[nb_output_streams - 1] = ost;
1074 ost->file_index = nb_output_files - 1;
1077 st->codec->codec_type = type;
1078 choose_encoder(o, oc, ost);
1080 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1081 if (!ost->enc_ctx) {
1082 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1085 ost->enc_ctx->codec_type = type;
1088 AVIOContext *s = NULL;
1089 char *buf = NULL, *arg = NULL, *preset = NULL;
1091 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1093 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1094 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1097 if (!buf[0] || buf[0] == '#') {
1101 if (!(arg = strchr(buf, '='))) {
1102 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1106 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1108 } while (!s->eof_reached);
1112 av_log(NULL, AV_LOG_FATAL,
1113 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1114 preset, ost->file_index, ost->index);
1118 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1121 ost->max_frames = INT64_MAX;
1122 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1123 for (i = 0; i<o->nb_max_frames; i++) {
1124 char *p = o->max_frames[i].specifier;
1125 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1126 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1131 ost->copy_prior_start = -1;
1132 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1134 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1136 if (next = strchr(bsf, ','))
1138 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1139 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1143 bsfc_prev->next = bsfc;
1145 ost->bitstream_filters = bsfc;
1151 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1153 uint32_t tag = strtol(codec_tag, &next, 0);
1155 tag = AV_RL32(codec_tag);
1156 ost->enc_ctx->codec_tag = tag;
1159 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1161 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1162 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1165 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1166 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1168 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1170 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1171 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1172 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1174 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1176 ost->source_index = source_index;
1177 if (source_index >= 0) {
1178 ost->sync_ist = input_streams[source_index];
1179 input_streams[source_index]->discard = 0;
1180 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1182 ost->last_mux_dts = AV_NOPTS_VALUE;
1187 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1190 const char *p = str;
1197 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1204 /* read file contents into a string */
1205 static uint8_t *read_file(const char *filename)
1207 AVIOContext *pb = NULL;
1208 AVIOContext *dyn_buf = NULL;
1209 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1210 uint8_t buf[1024], *str;
1213 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1217 ret = avio_open_dyn_buf(&dyn_buf);
1222 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1223 avio_write(dyn_buf, buf, ret);
1224 avio_w8(dyn_buf, 0);
1227 ret = avio_close_dyn_buf(dyn_buf, &str);
1233 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1236 AVStream *st = ost->st;
1238 if (ost->filters_script && ost->filters) {
1239 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1240 "output stream #%d:%d.\n", nb_output_files, st->index);
1244 if (ost->filters_script)
1245 return read_file(ost->filters_script);
1246 else if (ost->filters)
1247 return av_strdup(ost->filters);
1249 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1253 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1254 const OutputStream *ost, enum AVMediaType type)
1256 if (ost->filters_script || ost->filters) {
1257 av_log(NULL, AV_LOG_ERROR,
1258 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1259 "Filtering and streamcopy cannot be used together.\n",
1260 ost->filters ? "Filtergraph" : "Filtergraph script",
1261 ost->filters ? ost->filters : ost->filters_script,
1262 av_get_media_type_string(type), ost->file_index, ost->index);
1267 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1271 AVCodecContext *video_enc;
1272 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1274 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1276 video_enc = ost->enc_ctx;
1278 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1279 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1280 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1284 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1285 if (frame_aspect_ratio) {
1287 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1288 q.num <= 0 || q.den <= 0) {
1289 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1292 ost->frame_aspect_ratio = q;
1295 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1296 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1298 if (!ost->stream_copy) {
1299 const char *p = NULL;
1300 char *frame_size = NULL;
1301 char *frame_pix_fmt = NULL;
1302 char *intra_matrix = NULL, *inter_matrix = NULL;
1303 char *chroma_intra_matrix = NULL;
1307 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1308 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1309 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1313 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1314 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1315 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1316 ost->keep_pix_fmt = 1;
1317 if (!*++frame_pix_fmt)
1318 frame_pix_fmt = NULL;
1320 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1321 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1324 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1327 video_enc->gop_size = 0;
1328 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1330 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1331 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1334 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1336 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1337 if (chroma_intra_matrix) {
1338 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1340 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1343 av_codec_set_chroma_intra_matrix(video_enc, p);
1344 parse_matrix_coeffs(p, chroma_intra_matrix);
1346 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1348 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1349 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1352 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1355 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1356 for (i = 0; p; i++) {
1358 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1360 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1363 /* FIXME realloc failure */
1364 video_enc->rc_override =
1365 av_realloc(video_enc->rc_override,
1366 sizeof(RcOverride) * (i + 1));
1367 video_enc->rc_override[i].start_frame = start;
1368 video_enc->rc_override[i].end_frame = end;
1370 video_enc->rc_override[i].qscale = q;
1371 video_enc->rc_override[i].quality_factor = 1.0;
1374 video_enc->rc_override[i].qscale = 0;
1375 video_enc->rc_override[i].quality_factor = -q/100.0;
1380 video_enc->rc_override_count = i;
1383 video_enc->flags|= CODEC_FLAG_PSNR;
1386 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1389 video_enc->flags |= CODEC_FLAG_PASS1;
1390 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1393 video_enc->flags |= CODEC_FLAG_PASS2;
1394 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1398 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1399 if (ost->logfile_prefix &&
1400 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1403 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1404 if (ost->forced_keyframes)
1405 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1407 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1409 ost->top_field_first = -1;
1410 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1413 ost->avfilter = get_ost_filters(o, oc, ost);
1417 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1420 if (ost->stream_copy)
1421 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1426 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1431 AVCodecContext *audio_enc;
1433 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1436 audio_enc = ost->enc_ctx;
1437 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1439 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1440 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1442 if (!ost->stream_copy) {
1443 char *sample_fmt = NULL;
1445 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1447 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1449 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1450 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1454 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1456 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1457 ost->apad = av_strdup(ost->apad);
1459 ost->avfilter = get_ost_filters(o, oc, ost);
1463 /* check for channel mapping for this audio stream */
1464 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1465 AudioChannelMap *map = &o->audio_channel_maps[n];
1466 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1467 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1470 if (map->channel_idx == -1) {
1472 } else if (ost->source_index < 0) {
1473 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1474 ost->file_index, ost->st->index);
1477 ist = input_streams[ost->source_index];
1480 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1481 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1482 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1484 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1485 ost->file_index, ost->st->index);
1491 if (ost->stream_copy)
1492 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1497 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1501 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1502 if (!ost->stream_copy) {
1503 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1510 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1512 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1513 ost->stream_copy = 1;
1518 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1522 AVCodecContext *subtitle_enc;
1524 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1526 subtitle_enc = ost->enc_ctx;
1528 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1530 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1532 if (!ost->stream_copy) {
1533 char *frame_size = NULL;
1535 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1536 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1537 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1545 /* arg format is "output-stream-index:streamid-value". */
1546 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1548 OptionsContext *o = optctx;
1553 av_strlcpy(idx_str, arg, sizeof(idx_str));
1554 p = strchr(idx_str, ':');
1556 av_log(NULL, AV_LOG_FATAL,
1557 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1562 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1563 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1564 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1568 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1570 AVFormatContext *is = ifile->ctx;
1571 AVFormatContext *os = ofile->ctx;
1575 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1577 return AVERROR(ENOMEM);
1580 for (i = 0; i < is->nb_chapters; i++) {
1581 AVChapter *in_ch = is->chapters[i], *out_ch;
1582 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1583 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1584 AV_TIME_BASE_Q, in_ch->time_base);
1585 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1586 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1589 if (in_ch->end < ts_off)
1591 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1594 out_ch = av_mallocz(sizeof(AVChapter));
1596 return AVERROR(ENOMEM);
1598 out_ch->id = in_ch->id;
1599 out_ch->time_base = in_ch->time_base;
1600 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1601 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1604 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1606 os->chapters[os->nb_chapters++] = out_ch;
1611 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1614 AVFormatContext *ic = avformat_alloc_context();
1616 ic->interrupt_callback = int_cb;
1617 err = avformat_open_input(&ic, filename, NULL, NULL);
1620 /* copy stream format */
1621 for(i=0;i<ic->nb_streams;i++) {
1625 AVCodecContext *avctx;
1627 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1628 ost = new_output_stream(o, s, codec->type, -1);
1633 // FIXME: a more elegant solution is needed
1634 memcpy(st, ic->streams[i], sizeof(AVStream));
1636 st->info = av_malloc(sizeof(*st->info));
1637 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1639 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1641 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1642 choose_sample_fmt(st, codec);
1643 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1644 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1645 avcodec_copy_context(ost->enc_ctx, st->codec);
1648 avformat_close_input(&ic);
1652 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1653 AVFormatContext *oc)
1657 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1658 ofilter->out_tmp->pad_idx)) {
1659 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1660 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1662 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1667 ost->source_index = -1;
1668 ost->filter = ofilter;
1672 if (ost->stream_copy) {
1673 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1674 "which is fed from a complex filtergraph. Filtering and streamcopy "
1675 "cannot be used together.\n", ost->file_index, ost->index);
1679 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1680 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1681 av_log(NULL, AV_LOG_ERROR,
1682 "%s '%s' was specified through the %s option "
1683 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1684 "%s and -filter_complex cannot be used together for the same stream.\n",
1685 ost->filters ? "Filtergraph" : "Filtergraph script",
1686 ost->filters ? ost->filters : ost->filters_script,
1687 opt, ost->file_index, ost->index, opt);
1691 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1692 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1695 avfilter_inout_free(&ofilter->out_tmp);
1698 static int configure_complex_filters(void)
1702 for (i = 0; i < nb_filtergraphs; i++)
1703 if (!filtergraphs[i]->graph &&
1704 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1709 static int open_output_file(OptionsContext *o, const char *filename)
1711 AVFormatContext *oc;
1713 AVOutputFormat *file_oformat;
1717 AVDictionary *unused_opts = NULL;
1718 AVDictionaryEntry *e = NULL;
1720 if (configure_complex_filters() < 0) {
1721 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1725 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1726 o->stop_time = INT64_MAX;
1727 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1730 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1731 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1732 if (o->stop_time <= start_time) {
1733 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1734 o->stop_time = INT64_MAX;
1736 o->recording_time = o->stop_time - start_time;
1740 GROW_ARRAY(output_files, nb_output_files);
1741 of = av_mallocz(sizeof(*of));
1744 output_files[nb_output_files - 1] = of;
1746 of->ost_index = nb_output_streams;
1747 of->recording_time = o->recording_time;
1748 of->start_time = o->start_time;
1749 of->limit_filesize = o->limit_filesize;
1750 of->shortest = o->shortest;
1751 av_dict_copy(&of->opts, o->g->format_opts, 0);
1753 if (!strcmp(filename, "-"))
1756 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1758 print_error(filename, err);
1763 if (o->recording_time != INT64_MAX)
1764 oc->duration = o->recording_time;
1766 file_oformat= oc->oformat;
1767 oc->interrupt_callback = int_cb;
1769 /* create streams for all unlabeled output pads */
1770 for (i = 0; i < nb_filtergraphs; i++) {
1771 FilterGraph *fg = filtergraphs[i];
1772 for (j = 0; j < fg->nb_outputs; j++) {
1773 OutputFilter *ofilter = fg->outputs[j];
1775 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1778 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1779 ofilter->out_tmp->pad_idx)) {
1780 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1781 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1782 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1784 init_output_filter(ofilter, o, oc);
1788 /* ffserver seeking with date=... needs a date reference */
1789 if (!strcmp(file_oformat->name, "ffm") &&
1790 av_strstart(filename, "http:", NULL)) {
1791 int err = parse_option(o, "metadata", "creation_time=now", options);
1793 print_error(filename, err);
1798 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1799 av_strstart(filename, "http:", NULL)) {
1801 /* special case for files sent to ffserver: we get the stream
1802 parameters from ffserver */
1803 int err = read_ffserver_streams(o, oc, filename);
1805 print_error(filename, err);
1808 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1809 ost = output_streams[j];
1810 for (i = 0; i < nb_input_streams; i++) {
1811 ist = input_streams[i];
1812 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1814 ost->source_index= i;
1815 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1816 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1818 ist->st->discard = ist->user_set_discard;
1823 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));
1827 } else if (!o->nb_stream_maps) {
1828 char *subtitle_codec_name = NULL;
1829 /* pick the "best" stream of each type */
1831 /* video: highest resolution */
1832 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1833 int area = 0, idx = -1;
1834 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1835 for (i = 0; i < nb_input_streams; i++) {
1837 ist = input_streams[i];
1838 new_area = ist->st->codec->width * ist->st->codec->height;
1839 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1841 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1843 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1850 new_video_stream(o, oc, idx);
1853 /* audio: most channels */
1854 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1855 int channels = 0, idx = -1;
1856 for (i = 0; i < nb_input_streams; i++) {
1857 ist = input_streams[i];
1858 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1859 ist->st->codec->channels > channels) {
1860 channels = ist->st->codec->channels;
1865 new_audio_stream(o, oc, idx);
1868 /* subtitles: pick first */
1869 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1870 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1871 for (i = 0; i < nb_input_streams; i++)
1872 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1873 AVCodecDescriptor const *input_descriptor =
1874 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1875 AVCodecDescriptor const *output_descriptor = NULL;
1876 AVCodec const *output_codec =
1877 avcodec_find_encoder(oc->oformat->subtitle_codec);
1878 int input_props = 0, output_props = 0;
1880 output_descriptor = avcodec_descriptor_get(output_codec->id);
1881 if (input_descriptor)
1882 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1883 if (output_descriptor)
1884 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1885 if (subtitle_codec_name ||
1886 input_props & output_props ||
1887 // Map dvb teletext which has neither property to any output subtitle encoder
1888 input_descriptor && output_descriptor &&
1889 (!input_descriptor->props ||
1890 !output_descriptor->props)) {
1891 new_subtitle_stream(o, oc, i);
1896 /* do something with data? */
1898 for (i = 0; i < o->nb_stream_maps; i++) {
1899 StreamMap *map = &o->stream_maps[i];
1904 if (map->linklabel) {
1906 OutputFilter *ofilter = NULL;
1909 for (j = 0; j < nb_filtergraphs; j++) {
1910 fg = filtergraphs[j];
1911 for (k = 0; k < fg->nb_outputs; k++) {
1912 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1913 if (out && !strcmp(out->name, map->linklabel)) {
1914 ofilter = fg->outputs[k];
1921 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1922 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1925 init_output_filter(ofilter, o, oc);
1927 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1929 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1930 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1932 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1934 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1936 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1939 switch (ist->st->codec->codec_type) {
1940 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1941 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1942 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1943 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1944 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1946 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1947 map->file_index, map->stream_index);
1954 /* handle attached files */
1955 for (i = 0; i < o->nb_attachments; i++) {
1957 uint8_t *attachment;
1961 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1962 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1966 if ((len = avio_size(pb)) <= 0) {
1967 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1971 if (!(attachment = av_malloc(len))) {
1972 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1976 avio_read(pb, attachment, len);
1978 ost = new_attachment_stream(o, oc, -1);
1979 ost->stream_copy = 0;
1980 ost->attachment_filename = o->attachments[i];
1982 ost->enc_ctx->extradata = attachment;
1983 ost->enc_ctx->extradata_size = len;
1985 p = strrchr(o->attachments[i], '/');
1986 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1990 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1991 AVDictionaryEntry *e;
1992 ost = output_streams[i];
1994 if ((ost->stream_copy || ost->attachment_filename)
1995 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1996 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1997 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2001 /* check if all codec options have been used */
2002 unused_opts = strip_specifiers(o->g->codec_opts);
2003 for (i = of->ost_index; i < nb_output_streams; i++) {
2005 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2006 AV_DICT_IGNORE_SUFFIX)))
2007 av_dict_set(&unused_opts, e->key, NULL, 0);
2011 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2012 const AVClass *class = avcodec_get_class();
2013 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2014 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2017 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2018 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2019 "output file #%d (%s) is not an encoding option.\n", e->key,
2020 option->help ? option->help : "", nb_output_files - 1,
2025 // gop_timecode is injected by generic code but not always used
2026 if (!strcmp(e->key, "gop_timecode"))
2029 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2030 "output file #%d (%s) has not been used for any stream. The most "
2031 "likely reason is either wrong type (e.g. a video option with "
2032 "no video streams) or that it is a private option of some encoder "
2033 "which was not actually used for any stream.\n", e->key,
2034 option->help ? option->help : "", nb_output_files - 1, filename);
2036 av_dict_free(&unused_opts);
2038 /* check filename in case of an image number is expected */
2039 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2040 if (!av_filename_number_test(oc->filename)) {
2041 print_error(oc->filename, AVERROR(EINVAL));
2046 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2047 /* test if it already exists to avoid losing precious files */
2048 assert_file_overwrite(filename);
2051 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2052 &oc->interrupt_callback,
2054 print_error(filename, err);
2057 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2058 assert_file_overwrite(filename);
2060 if (o->mux_preload) {
2062 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2063 av_dict_set(&of->opts, "preload", buf, 0);
2065 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2068 for (i = 0; i < o->nb_metadata_map; i++) {
2070 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2072 if (in_file_index >= nb_input_files) {
2073 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2076 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2077 in_file_index >= 0 ?
2078 input_files[in_file_index]->ctx : NULL, o);
2082 if (o->chapters_input_file >= nb_input_files) {
2083 if (o->chapters_input_file == INT_MAX) {
2084 /* copy chapters from the first input file that has them*/
2085 o->chapters_input_file = -1;
2086 for (i = 0; i < nb_input_files; i++)
2087 if (input_files[i]->ctx->nb_chapters) {
2088 o->chapters_input_file = i;
2092 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2093 o->chapters_input_file);
2097 if (o->chapters_input_file >= 0)
2098 copy_chapters(input_files[o->chapters_input_file], of,
2099 !o->metadata_chapters_manual);
2101 /* copy global metadata by default */
2102 if (!o->metadata_global_manual && nb_input_files){
2103 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2104 AV_DICT_DONT_OVERWRITE);
2105 if(o->recording_time != INT64_MAX)
2106 av_dict_set(&oc->metadata, "duration", NULL, 0);
2107 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2109 if (!o->metadata_streams_manual)
2110 for (i = of->ost_index; i < nb_output_streams; i++) {
2112 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2114 ist = input_streams[output_streams[i]->source_index];
2115 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2116 if (!output_streams[i]->stream_copy)
2117 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2120 /* process manually set metadata */
2121 for (i = 0; i < o->nb_metadata; i++) {
2124 const char *stream_spec;
2125 int index = 0, j, ret = 0;
2127 val = strchr(o->metadata[i].u.str, '=');
2129 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2130 o->metadata[i].u.str);
2135 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2137 for (j = 0; j < oc->nb_streams; j++) {
2138 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2139 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2150 if (index < 0 || index >= oc->nb_chapters) {
2151 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2154 m = &oc->chapters[index]->metadata;
2157 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2160 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2167 static int opt_target(void *optctx, const char *opt, const char *arg)
2169 OptionsContext *o = optctx;
2170 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2171 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2173 if (!strncmp(arg, "pal-", 4)) {
2176 } else if (!strncmp(arg, "ntsc-", 5)) {
2179 } else if (!strncmp(arg, "film-", 5)) {
2183 /* Try to determine PAL/NTSC by peeking in the input files */
2184 if (nb_input_files) {
2186 for (j = 0; j < nb_input_files; j++) {
2187 for (i = 0; i < input_files[j]->nb_streams; i++) {
2188 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2189 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2192 fr = c->time_base.den * 1000 / c->time_base.num;
2196 } else if ((fr == 29970) || (fr == 23976)) {
2201 if (norm != UNKNOWN)
2205 if (norm != UNKNOWN)
2206 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2209 if (norm == UNKNOWN) {
2210 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2211 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2212 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2216 if (!strcmp(arg, "vcd")) {
2217 opt_video_codec(o, "c:v", "mpeg1video");
2218 opt_audio_codec(o, "c:a", "mp2");
2219 parse_option(o, "f", "vcd", options);
2221 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2222 parse_option(o, "r", frame_rates[norm], options);
2223 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2225 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2226 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2227 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2228 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2230 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2231 parse_option(o, "ar", "44100", options);
2232 parse_option(o, "ac", "2", options);
2234 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2235 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2237 /* We have to offset the PTS, so that it is consistent with the SCR.
2238 SCR starts at 36000, but the first two packs contain only padding
2239 and the first pack from the other stream, respectively, may also have
2240 been written before.
2241 So the real data starts at SCR 36000+3*1200. */
2242 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2243 } else if (!strcmp(arg, "svcd")) {
2245 opt_video_codec(o, "c:v", "mpeg2video");
2246 opt_audio_codec(o, "c:a", "mp2");
2247 parse_option(o, "f", "svcd", options);
2249 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2250 parse_option(o, "r", frame_rates[norm], options);
2251 parse_option(o, "pix_fmt", "yuv420p", options);
2252 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2254 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2255 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2256 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2257 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2258 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2260 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2261 parse_option(o, "ar", "44100", options);
2263 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2265 } else if (!strcmp(arg, "dvd")) {
2267 opt_video_codec(o, "c:v", "mpeg2video");
2268 opt_audio_codec(o, "c:a", "ac3");
2269 parse_option(o, "f", "dvd", options);
2271 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2272 parse_option(o, "r", frame_rates[norm], options);
2273 parse_option(o, "pix_fmt", "yuv420p", options);
2274 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2276 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2277 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2278 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2279 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2281 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.
2282 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2284 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2285 parse_option(o, "ar", "48000", options);
2287 } else if (!strncmp(arg, "dv", 2)) {
2289 parse_option(o, "f", "dv", options);
2291 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2292 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2293 norm == PAL ? "yuv420p" : "yuv411p", options);
2294 parse_option(o, "r", frame_rates[norm], options);
2296 parse_option(o, "ar", "48000", options);
2297 parse_option(o, "ac", "2", options);
2300 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2301 return AVERROR(EINVAL);
2306 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2308 av_free (vstats_filename);
2309 vstats_filename = av_strdup (arg);
2313 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2316 time_t today2 = time(NULL);
2317 struct tm *today = localtime(&today2);
2319 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2321 return opt_vstats_file(NULL, opt, filename);
2324 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2326 OptionsContext *o = optctx;
2327 return parse_option(o, "frames:v", arg, options);
2330 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2332 OptionsContext *o = optctx;
2333 return parse_option(o, "frames:a", arg, options);
2336 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2338 OptionsContext *o = optctx;
2339 return parse_option(o, "frames:d", arg, options);
2342 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2345 AVDictionary *cbak = codec_opts;
2346 AVDictionary *fbak = format_opts;
2350 ret = opt_default(NULL, opt, arg);
2352 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2353 av_dict_copy(&o->g->format_opts, format_opts, 0);
2354 av_dict_free(&codec_opts);
2355 av_dict_free(&format_opts);
2362 static int opt_preset(void *optctx, const char *opt, const char *arg)
2364 OptionsContext *o = optctx;
2366 char filename[1000], line[1000], tmp_line[1000];
2367 const char *codec_name = NULL;
2371 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2373 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2374 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2375 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2377 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2381 while (fgets(line, sizeof(line), f)) {
2382 char *key = tmp_line, *value, *endptr;
2384 if (strcspn(line, "#\n\r") == 0)
2386 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2387 if (!av_strtok(key, "=", &value) ||
2388 !av_strtok(value, "\r\n", &endptr)) {
2389 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2392 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2394 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2395 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2396 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2397 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2398 else if (opt_default_new(o, key, value) < 0) {
2399 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2400 filename, line, key, value);
2410 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2413 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2414 int ret = parse_option(o, s, arg, options);
2419 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2421 OptionsContext *o = optctx;
2423 if(!strcmp(opt, "ab")){
2424 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2426 } else if(!strcmp(opt, "b")){
2427 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2428 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2431 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2435 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2437 OptionsContext *o = optctx;
2440 if(!strcmp(opt, "qscale")){
2441 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2442 return parse_option(o, "q:v", arg, options);
2444 s = av_asprintf("q%s", opt + 6);
2445 ret = parse_option(o, s, arg, options);
2450 static int opt_profile(void *optctx, const char *opt, const char *arg)
2452 OptionsContext *o = optctx;
2453 if(!strcmp(opt, "profile")){
2454 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2455 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2458 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2462 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2464 OptionsContext *o = optctx;
2465 return parse_option(o, "filter:v", arg, options);
2468 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2470 OptionsContext *o = optctx;
2471 return parse_option(o, "filter:a", arg, options);
2474 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2476 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2477 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2478 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2479 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2481 if (video_sync_method == VSYNC_AUTO)
2482 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2486 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2488 OptionsContext *o = optctx;
2489 char *tcr = av_asprintf("timecode=%s", arg);
2490 int ret = parse_option(o, "metadata:g", tcr, options);
2492 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2497 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2499 OptionsContext *o = optctx;
2500 char layout_str[32];
2503 int ret, channels, ac_str_size;
2506 layout = av_get_channel_layout(arg);
2508 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2509 return AVERROR(EINVAL);
2511 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2512 ret = opt_default_new(o, opt, layout_str);
2516 /* set 'ac' option based on channel layout */
2517 channels = av_get_channel_layout_nb_channels(layout);
2518 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2519 stream_str = strchr(opt, ':');
2520 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2521 ac_str = av_mallocz(ac_str_size);
2523 return AVERROR(ENOMEM);
2524 av_strlcpy(ac_str, "ac", 3);
2526 av_strlcat(ac_str, stream_str, ac_str_size);
2527 ret = parse_option(o, ac_str, layout_str, options);
2533 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2535 OptionsContext *o = optctx;
2536 return parse_option(o, "q:a", arg, options);
2539 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2541 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2542 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2543 return AVERROR(ENOMEM);
2544 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2545 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2546 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2547 return AVERROR(ENOMEM);
2551 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2553 uint8_t *graph_desc = read_file(arg);
2555 return AVERROR(EINVAL);
2557 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2558 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2559 return AVERROR(ENOMEM);
2560 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2561 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2565 void show_help_default(const char *opt, const char *arg)
2567 /* per-file options have at least one of those set */
2568 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2569 int show_advanced = 0, show_avoptions = 0;
2572 if (!strcmp(opt, "long"))
2574 else if (!strcmp(opt, "full"))
2575 show_advanced = show_avoptions = 1;
2577 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2582 printf("Getting help:\n"
2583 " -h -- print basic options\n"
2584 " -h long -- print more options\n"
2585 " -h full -- print all options (including all format and codec specific options, very long)\n"
2586 " See man %s for detailed description of the options.\n"
2587 "\n", program_name);
2589 show_help_options(options, "Print help / information / capabilities:",
2592 show_help_options(options, "Global options (affect whole program "
2593 "instead of just one file:",
2594 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2596 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2597 per_file | OPT_EXIT, 0);
2599 show_help_options(options, "Per-file main options:", 0,
2600 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2601 OPT_EXIT, per_file);
2603 show_help_options(options, "Advanced per-file options:",
2604 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2606 show_help_options(options, "Video options:",
2607 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2609 show_help_options(options, "Advanced Video options:",
2610 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2612 show_help_options(options, "Audio options:",
2613 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2615 show_help_options(options, "Advanced Audio options:",
2616 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2617 show_help_options(options, "Subtitle options:",
2618 OPT_SUBTITLE, 0, 0);
2621 if (show_avoptions) {
2622 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2623 show_help_children(avcodec_get_class(), flags);
2624 show_help_children(avformat_get_class(), flags);
2626 show_help_children(sws_get_class(), flags);
2628 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2629 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2633 void show_usage(void)
2635 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2636 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2637 av_log(NULL, AV_LOG_INFO, "\n");
2645 static const OptionGroupDef groups[] = {
2646 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2647 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2650 static int open_files(OptionGroupList *l, const char *inout,
2651 int (*open_file)(OptionsContext*, const char*))
2655 for (i = 0; i < l->nb_groups; i++) {
2656 OptionGroup *g = &l->groups[i];
2662 ret = parse_optgroup(&o, g);
2664 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2665 "%s.\n", inout, g->arg);
2669 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2670 ret = open_file(&o, g->arg);
2673 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2677 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2683 int ffmpeg_parse_options(int argc, char **argv)
2685 OptionParseContext octx;
2689 memset(&octx, 0, sizeof(octx));
2691 /* split the commandline into an internal representation */
2692 ret = split_commandline(&octx, argc, argv, options, groups,
2693 FF_ARRAY_ELEMS(groups));
2695 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2699 /* apply global options */
2700 ret = parse_optgroup(NULL, &octx.global_opts);
2702 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2706 /* open input files */
2707 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2709 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2713 /* open output files */
2714 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2716 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2721 uninit_parse_context(&octx);
2723 av_strerror(ret, error, sizeof(error));
2724 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2729 static int opt_progress(void *optctx, const char *opt, const char *arg)
2731 AVIOContext *avio = NULL;
2734 if (!strcmp(arg, "-"))
2736 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2738 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2739 arg, av_err2str(ret));
2742 progress_avio = avio;
2746 #define OFFSET(x) offsetof(OptionsContext, x)
2747 const OptionDef options[] = {
2749 #include "cmdutils_common_opts.h"
2750 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2751 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2752 "force format", "fmt" },
2753 { "y", OPT_BOOL, { &file_overwrite },
2754 "overwrite output files" },
2755 { "n", OPT_BOOL, { &no_file_overwrite },
2756 "never overwrite output files" },
2757 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2758 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2759 "codec name", "codec" },
2760 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2761 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2762 "codec name", "codec" },
2763 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2764 OPT_OUTPUT, { .off = OFFSET(presets) },
2765 "preset name", "preset" },
2766 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2767 OPT_OUTPUT, { .func_arg = opt_map },
2768 "set input stream mapping",
2769 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2770 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2771 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2772 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2773 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2774 "set metadata information of outfile from infile",
2775 "outfile[,metadata]:infile[,metadata]" },
2776 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2777 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2778 "set chapters mapping", "input_file_index" },
2779 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2780 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2781 "record or transcode \"duration\" seconds of audio/video",
2783 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2784 "record or transcode stop time", "time_stop" },
2785 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2786 "set the limit file size in bytes", "limit_size" },
2787 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2788 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2789 "set the start time offset", "time_off" },
2790 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2791 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2792 "enable/disable accurate seeking with -ss" },
2793 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2794 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2795 "set the input ts offset", "time_off" },
2796 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2797 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2798 "set the input ts scale", "scale" },
2799 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2800 "set the recording timestamp ('now' to set the current time)", "time" },
2801 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2802 "add metadata", "string=string" },
2803 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2804 OPT_OUTPUT, { .func_arg = opt_data_frames },
2805 "set the number of data frames to record", "number" },
2806 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2807 "add timings for benchmarking" },
2808 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2809 "add timings for each task" },
2810 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2811 "write program-readable progress information", "url" },
2812 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2813 "enable or disable interaction on standard input" },
2814 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2815 "set max runtime in seconds", "limit" },
2816 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2817 "dump each input packet" },
2818 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2819 "when dumping packets, also dump the payload" },
2820 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2821 OPT_INPUT, { .off = OFFSET(rate_emu) },
2822 "read input at native frame rate", "" },
2823 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2824 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2825 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2826 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2827 "video sync method", "" },
2828 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2829 "audio sync method", "" },
2830 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2831 "audio drift threshold", "threshold" },
2832 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2833 "copy timestamps" },
2834 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2835 "copy input stream time base when stream copying", "mode" },
2836 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2837 OPT_OUTPUT, { .off = OFFSET(shortest) },
2838 "finish encoding within shortest input" },
2839 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2840 OPT_OUTPUT, { .off = OFFSET(apad) },
2842 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2843 "timestamp discontinuity delta threshold", "threshold" },
2844 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2845 "timestamp error delta threshold", "threshold" },
2846 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2847 "exit on error", "error" },
2848 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2849 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2850 "copy initial non-keyframes" },
2851 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2852 "copy or discard frames before start time" },
2853 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2854 "set the number of frames to record", "number" },
2855 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2856 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2857 "force codec tag/fourcc", "fourcc/tag" },
2858 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2859 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2860 "use fixed quality scale (VBR)", "q" },
2861 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2862 OPT_OUTPUT, { .func_arg = opt_qscale },
2863 "use fixed quality scale (VBR)", "q" },
2864 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2865 "set profile", "profile" },
2866 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2867 "set stream filtergraph", "filter_graph" },
2868 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2869 "read stream filtergraph description from a file", "filename" },
2870 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2871 "reinit filtergraph on input parameter changes", "" },
2872 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2873 "create a complex filtergraph", "graph_description" },
2874 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2875 "create a complex filtergraph", "graph_description" },
2876 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2877 "read complex filtergraph description from a file", "filename" },
2878 { "stats", OPT_BOOL, { &print_stats },
2879 "print progress report during encoding", },
2880 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2881 OPT_OUTPUT, { .func_arg = opt_attach },
2882 "add an attachment to the output file", "filename" },
2883 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2884 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2885 "extract an attachment into a file", "filename" },
2886 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2887 "print timestamp debugging info" },
2888 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2889 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2890 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2891 OPT_INPUT, { .off = OFFSET(discard) },
2895 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2896 "set the number of video frames to record", "number" },
2897 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2898 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2899 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2900 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2901 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2902 "set frame size (WxH or abbreviation)", "size" },
2903 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2904 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2905 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2906 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2907 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2908 "set pixel format", "format" },
2909 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2910 "set the number of bits per raw sample", "number" },
2911 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2912 "deprecated use -g 1" },
2913 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2915 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2916 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2917 "rate control override for specific intervals", "override" },
2918 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2919 OPT_OUTPUT, { .func_arg = opt_video_codec },
2920 "force video codec ('copy' to copy stream)", "codec" },
2921 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2923 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2925 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2926 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2927 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2928 "select the pass number (1 to 3)", "n" },
2929 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2930 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2931 "select two pass log file name prefix", "prefix" },
2932 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2933 "this option is deprecated, use the yadif filter instead" },
2934 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2935 "calculate PSNR of compressed frames" },
2936 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2937 "dump video coding statistics to file" },
2938 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2939 "dump video coding statistics to file", "file" },
2940 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2941 "set video filters", "filter_graph" },
2942 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2943 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2944 "specify intra matrix coeffs", "matrix" },
2945 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2946 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2947 "specify inter matrix coeffs", "matrix" },
2948 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2949 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2950 "specify intra matrix coeffs", "matrix" },
2951 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2952 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2953 "top=1/bottom=0/auto=-1 field first", "" },
2954 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2955 OPT_OUTPUT, { .func_arg = opt_old2new },
2956 "force video tag/fourcc", "fourcc/tag" },
2957 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2958 "show QP histogram" },
2959 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2960 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2961 "force the selected framerate, disable the best supported framerate selection" },
2962 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2963 OPT_OUTPUT, { .func_arg = opt_streamid },
2964 "set the value of an outfile streamid", "streamIndex:value" },
2965 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2966 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2967 "force key frames at specified timestamps", "timestamps" },
2968 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2969 "audio bitrate (please use -b:a)", "bitrate" },
2970 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2971 "video bitrate (please use -b:v)", "bitrate" },
2972 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2973 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2974 "use HW accelerated decoding", "hwaccel name" },
2975 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2976 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2977 "select a device for HW acceleration" "devicename" },
2980 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2981 "set the number of audio frames to record", "number" },
2982 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2983 "set audio quality (codec-specific)", "quality", },
2984 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2985 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2986 "set audio sampling rate (in Hz)", "rate" },
2987 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2988 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2989 "set number of audio channels", "channels" },
2990 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2992 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2993 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2994 "force audio codec ('copy' to copy stream)", "codec" },
2995 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2996 OPT_OUTPUT, { .func_arg = opt_old2new },
2997 "force audio tag/fourcc", "fourcc/tag" },
2998 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2999 "change audio volume (256=normal)" , "volume" },
3000 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3001 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3002 "set sample format", "format" },
3003 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3004 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3005 "set channel layout", "layout" },
3006 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3007 "set audio filters", "filter_graph" },
3008 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3009 "set the maximum number of channels to try to guess the channel layout" },
3011 /* subtitle options */
3012 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3013 "disable subtitle" },
3014 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3015 "force subtitle codec ('copy' to copy stream)", "codec" },
3016 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3017 , "force subtitle tag/fourcc", "fourcc/tag" },
3018 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3019 "fix subtitles duration" },
3020 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3021 "set canvas size (WxH or abbreviation)", "size" },
3024 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3025 "deprecated, use -channel", "channel" },
3026 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3027 "deprecated, use -standard", "standard" },
3028 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3031 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3032 "set the maximum demux-decode delay", "seconds" },
3033 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3034 "set the initial demux-decode delay", "seconds" },
3035 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3036 "override the options from ffserver", "" },
3038 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3039 "A comma-separated list of bitstream filters", "bitstream_filters" },
3040 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3041 "deprecated", "audio bitstream_filters" },
3042 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3043 "deprecated", "video bitstream_filters" },
3045 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3046 "set the audio options to the indicated preset", "preset" },
3047 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3048 "set the video options to the indicated preset", "preset" },
3049 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3050 "set the subtitle options to the indicated preset", "preset" },
3051 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3052 "set options from indicated preset file", "filename" },
3053 /* data codec support */
3054 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3055 "force data codec ('copy' to copy stream)", "codec" },
3056 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },