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"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
68 char *vstats_filename;
70 float audio_drift_threshold = 0.1;
71 float dts_delta_threshold = 10;
72 float dts_error_threshold = 3600*30;
74 int audio_volume = 256;
75 int audio_sync_method = 0;
76 int video_sync_method = VSYNC_AUTO;
77 int do_deinterlace = 0;
79 int do_benchmark_all = 0;
85 int exit_on_error = 0;
89 int stdin_interaction = 1;
90 int frame_bits_per_raw_sample = 0;
93 static int intra_only = 0;
94 static const char *video_codec_name = NULL;
95 static const char *audio_codec_name = NULL;
96 static const char *subtitle_codec_name = NULL;
97 static int file_overwrite = 0;
98 static int no_file_overwrite = 0;
99 static int video_discard = 0;
100 static int intra_dc_precision = 8;
101 static int do_psnr = 0;
102 static int input_sync;
104 void reset_options(OptionsContext *o, int is_input)
106 const OptionDef *po = options;
107 OptionsContext bak= *o;
110 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
112 void *dst = (uint8_t*)o + po->u.off;
114 if (po->flags & OPT_SPEC) {
115 SpecifierOpt **so = dst;
116 int i, *count = (int*)(so + 1);
117 for (i = 0; i < *count; i++) {
118 av_freep(&(*so)[i].specifier);
119 if (po->flags & OPT_STRING)
120 av_freep(&(*so)[i].u.str);
124 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
129 for (i = 0; i < o->nb_stream_maps; i++)
130 av_freep(&o->stream_maps[i].linklabel);
131 av_freep(&o->stream_maps);
132 av_freep(&o->audio_channel_maps);
133 av_freep(&o->streamid_map);
135 memset(o, 0, sizeof(*o));
138 o->recording_time = bak.recording_time;
139 if (o->recording_time != INT64_MAX)
140 av_log(NULL, AV_LOG_WARNING,
141 "-t is not an input option, keeping it for the next output;"
142 " consider fixing your command line.\n");
144 o->recording_time = INT64_MAX;
145 o->mux_max_delay = 0.7;
146 o->limit_filesize = UINT64_MAX;
147 o->chapters_input_file = INT_MAX;
154 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
157 return AVERROR(EINVAL);
160 static int opt_pad(void *optctx, const char *opt, const char *arg)
162 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
168 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
169 return opt_default(optctx, "channel", arg);
172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
175 return opt_default(optctx, "standard", arg);
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 audio_codec_name = arg;
182 return parse_option(o, "codec:a", arg, options);
185 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
187 OptionsContext *o = optctx;
188 video_codec_name = arg;
189 return parse_option(o, "codec:v", arg, options);
192 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
194 OptionsContext *o = optctx;
195 subtitle_codec_name = arg;
196 return parse_option(o, "codec:s", arg, options);
199 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:d", arg, options);
205 static int opt_map(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
209 int i, negative = 0, file_idx;
210 int sync_file_idx = -1, sync_stream_idx = 0;
218 map = av_strdup(arg);
220 /* parse sync stream first, just pick first matching stream */
221 if (sync = strchr(map, ',')) {
223 sync_file_idx = strtol(sync + 1, &sync, 0);
224 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
225 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
230 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
231 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
232 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
236 if (i == input_files[sync_file_idx]->nb_streams) {
237 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
238 "match any streams.\n", arg);
245 /* this mapping refers to lavfi output */
246 const char *c = map + 1;
247 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
248 &o->nb_stream_maps, o->nb_stream_maps + 1);
249 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->linklabel = av_get_token(&c, "]");
252 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
256 file_idx = strtol(map, &p, 0);
257 if (file_idx >= nb_input_files || file_idx < 0) {
258 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
262 /* disable some already defined maps */
263 for (i = 0; i < o->nb_stream_maps; i++) {
264 m = &o->stream_maps[i];
265 if (file_idx == m->file_index &&
266 check_stream_specifier(input_files[m->file_index]->ctx,
267 input_files[m->file_index]->ctx->streams[m->stream_index],
268 *p == ':' ? p + 1 : p) > 0)
272 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274 *p == ':' ? p + 1 : p) <= 0)
276 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
277 &o->nb_stream_maps, o->nb_stream_maps + 1);
278 m = &o->stream_maps[o->nb_stream_maps - 1];
280 m->file_index = file_idx;
283 if (sync_file_idx >= 0) {
284 m->sync_file_index = sync_file_idx;
285 m->sync_stream_index = sync_stream_idx;
287 m->sync_file_index = file_idx;
288 m->sync_stream_index = i;
294 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
302 static int opt_attach(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
305 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
306 &o->nb_attachments, o->nb_attachments + 1);
307 o->attachments[o->nb_attachments - 1] = arg;
311 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
313 OptionsContext *o = optctx;
318 o->audio_channel_maps =
319 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
320 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
321 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
323 /* muted channel syntax */
324 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
325 if ((n == 1 || n == 3) && m->channel_idx == -1) {
326 m->file_idx = m->stream_idx = -1;
328 m->ofile_idx = m->ostream_idx = -1;
333 n = sscanf(arg, "%d.%d.%d:%d.%d",
334 &m->file_idx, &m->stream_idx, &m->channel_idx,
335 &m->ofile_idx, &m->ostream_idx);
337 if (n != 3 && n != 5) {
338 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
339 "[file.stream.channel|-1][:syncfile:syncstream]\n");
343 if (n != 5) // only file.stream.channel specified
344 m->ofile_idx = m->ostream_idx = -1;
347 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
348 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
352 if (m->stream_idx < 0 ||
353 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
355 m->file_idx, m->stream_idx);
358 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
359 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
360 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
361 m->file_idx, m->stream_idx);
364 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
366 m->file_idx, m->stream_idx, m->channel_idx);
373 * Parse a metadata specifier in arg.
374 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
375 * @param index for type c/p, chapter/program index is written here
376 * @param stream_spec for type s, the stream specifier is written here
378 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
386 if (*(++arg) && *arg != ':') {
387 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
390 *stream_spec = *arg == ':' ? arg + 1 : "";
395 *index = strtol(++arg, NULL, 0);
398 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
405 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
407 AVDictionary **meta_in = NULL;
408 AVDictionary **meta_out = NULL;
410 char type_in, type_out;
411 const char *istream_spec = NULL, *ostream_spec = NULL;
412 int idx_in = 0, idx_out = 0;
414 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
415 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
418 if (type_out == 'g' || !*outspec)
419 o->metadata_global_manual = 1;
420 if (type_out == 's' || !*outspec)
421 o->metadata_streams_manual = 1;
422 if (type_out == 'c' || !*outspec)
423 o->metadata_chapters_manual = 1;
427 if (type_in == 'g' || type_out == 'g')
428 o->metadata_global_manual = 1;
429 if (type_in == 's' || type_out == 's')
430 o->metadata_streams_manual = 1;
431 if (type_in == 'c' || type_out == 'c')
432 o->metadata_chapters_manual = 1;
434 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
435 if ((index) < 0 || (index) >= (nb_elems)) {\
436 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
441 #define SET_DICT(type, meta, context, index)\
444 meta = &context->metadata;\
447 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
448 meta = &context->chapters[index]->metadata;\
451 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
452 meta = &context->programs[index]->metadata;\
454 default: av_assert0(0);\
459 SET_DICT(type_in, meta_in, ic, idx_in);
460 SET_DICT(type_out, meta_out, oc, idx_out);
462 /* for input streams choose first matching stream */
463 if (type_in == 's') {
464 for (i = 0; i < ic->nb_streams; i++) {
465 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
466 meta_in = &ic->streams[i]->metadata;
472 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
477 if (type_out == 's') {
478 for (i = 0; i < oc->nb_streams; i++) {
479 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
480 meta_out = &oc->streams[i]->metadata;
481 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
486 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
491 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
493 OptionsContext *o = optctx;
495 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
496 struct tm time = *gmtime((time_t*)&recording_timestamp);
497 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
498 parse_option(o, "metadata", buf, options);
500 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
501 "tag instead.\n", opt);
505 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
507 const AVCodecDescriptor *desc;
508 const char *codec_string = encoder ? "encoder" : "decoder";
512 avcodec_find_encoder_by_name(name) :
513 avcodec_find_decoder_by_name(name);
515 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
516 codec = encoder ? avcodec_find_encoder(desc->id) :
517 avcodec_find_decoder(desc->id);
519 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
520 codec_string, codec->name, desc->name);
524 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
527 if (codec->type != type) {
528 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
534 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
536 char *codec_name = NULL;
538 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
540 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
541 st->codec->codec_id = codec->id;
544 return avcodec_find_decoder(st->codec->codec_id);
548 * Add all the streams from the given input file to the global
549 * list of input streams.
551 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
554 char *next, *codec_tag = NULL;
556 for (i = 0; i < ic->nb_streams; i++) {
557 AVStream *st = ic->streams[i];
558 AVCodecContext *dec = st->codec;
559 InputStream *ist = av_mallocz(sizeof(*ist));
560 char *framerate = NULL;
565 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
566 input_streams[nb_input_streams - 1] = ist;
569 ist->file_index = nb_input_files;
571 st->discard = AVDISCARD_ALL;
572 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
575 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
577 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
579 uint32_t tag = strtol(codec_tag, &next, 0);
581 tag = AV_RL32(codec_tag);
582 st->codec->codec_tag = tag;
585 ist->dec = choose_decoder(o, ic, st);
587 switch (dec->codec_type) {
588 case AVMEDIA_TYPE_VIDEO:
590 ist->dec = avcodec_find_decoder(dec->codec_id);
592 dec->flags |= CODEC_FLAG_EMU_EDGE;
595 ist->resample_height = dec->height;
596 ist->resample_width = dec->width;
597 ist->resample_pix_fmt = dec->pix_fmt;
599 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
600 if (framerate && av_parse_video_rate(&ist->framerate,
602 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
607 ist->top_field_first = -1;
608 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
611 case AVMEDIA_TYPE_AUDIO:
612 guess_input_channel_layout(ist);
614 ist->resample_sample_fmt = dec->sample_fmt;
615 ist->resample_sample_rate = dec->sample_rate;
616 ist->resample_channels = dec->channels;
617 ist->resample_channel_layout = dec->channel_layout;
620 case AVMEDIA_TYPE_DATA:
621 case AVMEDIA_TYPE_SUBTITLE:
623 ist->dec = avcodec_find_decoder(dec->codec_id);
624 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
626 case AVMEDIA_TYPE_ATTACHMENT:
627 case AVMEDIA_TYPE_UNKNOWN:
635 static void assert_file_overwrite(const char *filename)
637 if ((!file_overwrite || no_file_overwrite) &&
638 (strchr(filename, ':') == NULL || filename[1] == ':' ||
639 av_strstart(filename, "file:", NULL))) {
640 if (avio_check(filename, 0) == 0) {
641 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
642 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
645 signal(SIGINT, SIG_DFL);
647 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
653 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
660 static void dump_attachment(AVStream *st, const char *filename)
663 AVIOContext *out = NULL;
664 AVDictionaryEntry *e;
666 if (!st->codec->extradata_size) {
667 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
668 nb_input_files - 1, st->index);
671 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
674 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
675 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
679 assert_file_overwrite(filename);
681 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
682 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
687 avio_write(out, st->codec->extradata, st->codec->extradata_size);
692 static int opt_input_file(void *optctx, const char *opt, const char *filename)
694 OptionsContext *o = optctx;
696 AVInputFormat *file_iformat = NULL;
701 int orig_nb_streams; // number of streams before avformat_find_stream_info
702 char * video_codec_name = NULL;
703 char * audio_codec_name = NULL;
704 char *subtitle_codec_name = NULL;
707 if (!(file_iformat = av_find_input_format(o->format))) {
708 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
713 if (!strcmp(filename, "-"))
716 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
717 strcmp(filename, "/dev/stdin");
719 /* get default parameters from command line */
720 ic = avformat_alloc_context();
722 print_error(filename, AVERROR(ENOMEM));
725 if (o->nb_audio_sample_rate) {
726 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
727 av_dict_set(&format_opts, "sample_rate", buf, 0);
729 if (o->nb_audio_channels) {
730 /* because we set audio_channels based on both the "ac" and
731 * "channel_layout" options, we need to check that the specified
732 * demuxer actually has the "channels" option before setting it */
733 if (file_iformat && file_iformat->priv_class &&
734 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
735 AV_OPT_SEARCH_FAKE_OBJ)) {
736 snprintf(buf, sizeof(buf), "%d",
737 o->audio_channels[o->nb_audio_channels - 1].u.i);
738 av_dict_set(&format_opts, "channels", buf, 0);
741 if (o->nb_frame_rates) {
742 /* set the format-level framerate option;
743 * this is important for video grabbers, e.g. x11 */
744 if (file_iformat && file_iformat->priv_class &&
745 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
746 AV_OPT_SEARCH_FAKE_OBJ)) {
747 av_dict_set(&format_opts, "framerate",
748 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
751 if (o->nb_frame_sizes) {
752 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
754 if (o->nb_frame_pix_fmts)
755 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
757 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
758 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
759 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
761 ic->video_codec_id = video_codec_name ?
762 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
763 ic->audio_codec_id = audio_codec_name ?
764 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
765 ic->subtitle_codec_id= subtitle_codec_name ?
766 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
767 ic->flags |= AVFMT_FLAG_NONBLOCK;
768 ic->interrupt_callback = int_cb;
770 /* open the input file with generic avformat function */
771 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
773 print_error(filename, err);
776 assert_avoptions(format_opts);
778 /* apply forced codec ids */
779 for (i = 0; i < ic->nb_streams; i++)
780 choose_decoder(o, ic, ic->streams[i]);
782 /* Set AVCodecContext options for avformat_find_stream_info */
783 opts = setup_find_stream_info_opts(ic, codec_opts);
784 orig_nb_streams = ic->nb_streams;
786 /* If not enough info to get the stream parameters, we decode the
787 first frames to get it. (used in mpeg case for example) */
788 ret = avformat_find_stream_info(ic, opts);
790 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
791 avformat_close_input(&ic);
795 timestamp = o->start_time;
796 /* add the stream start time */
797 if (ic->start_time != AV_NOPTS_VALUE)
798 timestamp += ic->start_time;
800 /* if seeking requested, we execute it */
801 if (o->start_time != 0) {
802 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
804 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
805 filename, (double)timestamp / AV_TIME_BASE);
809 /* update the current parameters so that they match the one of the input stream */
810 add_input_streams(o, ic);
812 /* dump the file content */
813 av_dump_format(ic, nb_input_files, filename, 0);
815 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
816 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
819 input_files[nb_input_files - 1]->ctx = ic;
820 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
821 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
822 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
823 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
825 for (i = 0; i < o->nb_dump_attachment; i++) {
828 for (j = 0; j < ic->nb_streams; j++) {
829 AVStream *st = ic->streams[j];
831 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
832 dump_attachment(st, o->dump_attachment[i].u.str);
836 for (i = 0; i < orig_nb_streams; i++)
837 av_dict_free(&opts[i]);
844 static uint8_t *get_line(AVIOContext *s)
850 if (avio_open_dyn_buf(&line) < 0) {
851 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
855 while ((c = avio_r8(s)) && c != '\n')
858 avio_close_dyn_buf(line, &buf);
863 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
867 const char *base[3] = { getenv("AVCONV_DATADIR"),
872 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
876 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
877 i != 1 ? "" : "/.avconv", codec_name, preset_name);
878 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
881 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
882 i != 1 ? "" : "/.avconv", preset_name);
883 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
889 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
891 char *codec_name = NULL;
893 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
895 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
896 NULL, ost->st->codec->codec_type);
897 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
898 } else if (!strcmp(codec_name, "copy"))
899 ost->stream_copy = 1;
901 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
902 ost->st->codec->codec_id = ost->enc->id;
906 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
909 AVStream *st = avformat_new_stream(oc, NULL);
910 int idx = oc->nb_streams - 1, ret = 0;
911 char *bsf = NULL, *next, *codec_tag = NULL;
912 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
914 char *buf = NULL, *arg = NULL, *preset = NULL;
915 AVIOContext *s = NULL;
918 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
922 if (oc->nb_streams - 1 < o->nb_streamid_map)
923 st->id = o->streamid_map[oc->nb_streams - 1];
925 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
926 nb_output_streams + 1);
927 if (!(ost = av_mallocz(sizeof(*ost))))
929 output_streams[nb_output_streams - 1] = ost;
931 ost->file_index = nb_output_files;
934 st->codec->codec_type = type;
935 choose_encoder(o, oc, ost);
937 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
940 avcodec_get_context_defaults3(st->codec, ost->enc);
941 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
943 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
944 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
947 if (!buf[0] || buf[0] == '#') {
951 if (!(arg = strchr(buf, '='))) {
952 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
956 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
958 } while (!s->eof_reached);
962 av_log(NULL, AV_LOG_FATAL,
963 "Preset %s specified for stream %d:%d, but could not be opened.\n",
964 preset, ost->file_index, ost->index);
968 ost->max_frames = INT64_MAX;
969 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
971 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
973 if (next = strchr(bsf, ','))
975 if (!(bsfc = av_bitstream_filter_init(bsf))) {
976 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
980 bsfc_prev->next = bsfc;
982 ost->bitstream_filters = bsfc;
988 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
990 uint32_t tag = strtol(codec_tag, &next, 0);
992 tag = AV_RL32(codec_tag);
993 st->codec->codec_tag = tag;
996 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
997 if (qscale >= 0 || same_quant) {
998 st->codec->flags |= CODEC_FLAG_QSCALE;
999 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1002 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1003 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1005 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1006 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1007 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1009 ost->source_index = source_index;
1010 if (source_index >= 0) {
1011 ost->sync_ist = input_streams[source_index];
1012 input_streams[source_index]->discard = 0;
1013 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1019 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1022 const char *p = str;
1029 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1036 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1040 AVCodecContext *video_enc;
1041 char *frame_rate = NULL;
1043 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1045 video_enc = st->codec;
1047 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1048 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1049 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1053 if (!ost->stream_copy) {
1054 const char *p = NULL;
1055 char *frame_size = NULL;
1056 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1057 char *intra_matrix = NULL, *inter_matrix = NULL;
1058 const char *filters = "null";
1062 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1063 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1064 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1068 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1069 if (frame_aspect_ratio) {
1071 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1072 q.num <= 0 || q.den <= 0) {
1073 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1076 ost->frame_aspect_ratio = av_q2d(q);
1079 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1080 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1081 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1082 ost->keep_pix_fmt = 1;
1083 if (!*++frame_pix_fmt)
1084 frame_pix_fmt = NULL;
1086 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
1087 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1090 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1093 video_enc->gop_size = 0;
1094 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1096 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1097 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1100 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1102 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1104 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1105 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1108 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1111 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1112 for (i = 0; p; i++) {
1114 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1116 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1119 /* FIXME realloc failure */
1120 video_enc->rc_override =
1121 av_realloc(video_enc->rc_override,
1122 sizeof(RcOverride) * (i + 1));
1123 video_enc->rc_override[i].start_frame = start;
1124 video_enc->rc_override[i].end_frame = end;
1126 video_enc->rc_override[i].qscale = q;
1127 video_enc->rc_override[i].quality_factor = 1.0;
1130 video_enc->rc_override[i].qscale = 0;
1131 video_enc->rc_override[i].quality_factor = -q/100.0;
1136 video_enc->rc_override_count = i;
1137 if (!video_enc->rc_initial_buffer_occupancy)
1138 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1139 video_enc->intra_dc_precision = intra_dc_precision - 8;
1142 video_enc->flags|= CODEC_FLAG_PSNR;
1145 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1148 video_enc->flags |= CODEC_FLAG_PASS1;
1151 video_enc->flags |= CODEC_FLAG_PASS2;
1155 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1156 if (ost->logfile_prefix &&
1157 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1160 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1161 if (ost->forced_keyframes)
1162 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1164 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1166 ost->top_field_first = -1;
1167 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1169 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1170 ost->avfilter = av_strdup(filters);
1172 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1178 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1183 AVCodecContext *audio_enc;
1185 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1188 audio_enc = st->codec;
1189 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1191 if (!ost->stream_copy) {
1192 char *sample_fmt = NULL;
1193 const char *filters = "anull";
1195 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1197 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1199 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1200 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1204 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1206 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1208 av_assert1(filters);
1209 ost->avfilter = av_strdup(filters);
1211 /* check for channel mapping for this audio stream */
1212 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1213 AudioChannelMap *map = &o->audio_channel_maps[n];
1214 InputStream *ist = input_streams[ost->source_index];
1215 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1216 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1217 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1218 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1219 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1221 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1222 ost->file_index, ost->st->index);
1230 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1234 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1235 if (!ost->stream_copy) {
1236 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1243 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1245 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1246 ost->stream_copy = 1;
1250 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1254 AVCodecContext *subtitle_enc;
1256 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1258 subtitle_enc = st->codec;
1260 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1262 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1264 if (!ost->stream_copy) {
1265 char *frame_size = NULL;
1267 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1268 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1277 /* arg format is "output-stream-index:streamid-value". */
1278 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1280 OptionsContext *o = optctx;
1285 av_strlcpy(idx_str, arg, sizeof(idx_str));
1286 p = strchr(idx_str, ':');
1288 av_log(NULL, AV_LOG_FATAL,
1289 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1294 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1295 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1296 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1300 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1302 AVFormatContext *is = ifile->ctx;
1303 AVFormatContext *os = ofile->ctx;
1306 for (i = 0; i < is->nb_chapters; i++) {
1307 AVChapter *in_ch = is->chapters[i], *out_ch;
1308 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1309 AV_TIME_BASE_Q, in_ch->time_base);
1310 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1311 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1314 if (in_ch->end < ts_off)
1316 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1319 out_ch = av_mallocz(sizeof(AVChapter));
1321 return AVERROR(ENOMEM);
1323 out_ch->id = in_ch->id;
1324 out_ch->time_base = in_ch->time_base;
1325 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1326 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1329 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1332 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1334 return AVERROR(ENOMEM);
1335 os->chapters[os->nb_chapters - 1] = out_ch;
1340 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1343 AVFormatContext *ic = avformat_alloc_context();
1345 ic->interrupt_callback = int_cb;
1346 err = avformat_open_input(&ic, filename, NULL, NULL);
1349 /* copy stream format */
1350 for(i=0;i<ic->nb_streams;i++) {
1354 AVCodecContext *avctx;
1356 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1357 ost = new_output_stream(o, s, codec->type, -1);
1362 // FIXME: a more elegant solution is needed
1363 memcpy(st, ic->streams[i], sizeof(AVStream));
1365 st->info = av_malloc(sizeof(*st->info));
1366 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1368 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1370 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1371 choose_sample_fmt(st, codec);
1372 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1373 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1376 avformat_close_input(&ic);
1380 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1381 AVFormatContext *oc)
1385 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1386 ofilter->out_tmp->pad_idx)) {
1387 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1388 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1390 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1395 ost->source_index = -1;
1396 ost->filter = ofilter;
1400 if (ost->stream_copy) {
1401 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1402 "which is fed from a complex filtergraph. Filtering and streamcopy "
1403 "cannot be used together.\n", ost->file_index, ost->index);
1407 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1408 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1411 avfilter_inout_free(&ofilter->out_tmp);
1414 static int configure_complex_filters(void)
1418 for (i = 0; i < nb_filtergraphs; i++)
1419 if (!filtergraphs[i]->graph &&
1420 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1425 void opt_output_file(void *optctx, const char *filename)
1427 OptionsContext *o = optctx;
1428 AVFormatContext *oc;
1430 AVOutputFormat *file_oformat;
1434 if (configure_complex_filters() < 0) {
1435 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1439 if (!strcmp(filename, "-"))
1442 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1444 print_error(filename, err);
1447 file_oformat= oc->oformat;
1448 oc->interrupt_callback = int_cb;
1450 /* create streams for all unlabeled output pads */
1451 for (i = 0; i < nb_filtergraphs; i++) {
1452 FilterGraph *fg = filtergraphs[i];
1453 for (j = 0; j < fg->nb_outputs; j++) {
1454 OutputFilter *ofilter = fg->outputs[j];
1456 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1459 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1460 ofilter->out_tmp->pad_idx)) {
1461 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1462 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1463 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1465 init_output_filter(ofilter, o, oc);
1469 if (!strcmp(file_oformat->name, "ffm") &&
1470 av_strstart(filename, "http:", NULL)) {
1472 /* special case for files sent to ffserver: we get the stream
1473 parameters from ffserver */
1474 int err = read_ffserver_streams(o, oc, filename);
1476 print_error(filename, err);
1479 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1480 ost = output_streams[j];
1481 for (i = 0; i < nb_input_streams; i++) {
1482 ist = input_streams[i];
1483 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1485 ost->source_index= i;
1486 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1487 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1489 ist->st->discard = AVDISCARD_NONE;
1494 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));
1498 } else if (!o->nb_stream_maps) {
1499 /* pick the "best" stream of each type */
1501 /* video: highest resolution */
1502 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1503 int area = 0, idx = -1;
1504 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1505 for (i = 0; i < nb_input_streams; i++) {
1506 ist = input_streams[i];
1507 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1508 ist->st->codec->width * ist->st->codec->height > area) {
1509 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1511 area = ist->st->codec->width * ist->st->codec->height;
1516 new_video_stream(o, oc, idx);
1519 /* audio: most channels */
1520 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1521 int channels = 0, idx = -1;
1522 for (i = 0; i < nb_input_streams; i++) {
1523 ist = input_streams[i];
1524 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1525 ist->st->codec->channels > channels) {
1526 channels = ist->st->codec->channels;
1531 new_audio_stream(o, oc, idx);
1534 /* subtitles: pick first */
1535 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1536 for (i = 0; i < nb_input_streams; i++)
1537 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1538 new_subtitle_stream(o, oc, i);
1542 /* do something with data? */
1544 for (i = 0; i < o->nb_stream_maps; i++) {
1545 StreamMap *map = &o->stream_maps[i];
1546 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1551 if (map->linklabel) {
1553 OutputFilter *ofilter = NULL;
1556 for (j = 0; j < nb_filtergraphs; j++) {
1557 fg = filtergraphs[j];
1558 for (k = 0; k < fg->nb_outputs; k++) {
1559 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1560 if (out && !strcmp(out->name, map->linklabel)) {
1561 ofilter = fg->outputs[k];
1568 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1569 "in any defined filter graph.\n", map->linklabel);
1572 init_output_filter(ofilter, o, oc);
1574 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1575 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1577 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1579 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1581 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1584 switch (ist->st->codec->codec_type) {
1585 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1586 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1587 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1588 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1589 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1591 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1592 map->file_index, map->stream_index);
1600 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1601 AVDictionaryEntry *e;
1602 ost = output_streams[i];
1604 if ( ost->stream_copy
1605 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1606 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1607 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1611 /* handle attached files */
1612 for (i = 0; i < o->nb_attachments; i++) {
1614 uint8_t *attachment;
1618 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1619 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1623 if ((len = avio_size(pb)) <= 0) {
1624 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1628 if (!(attachment = av_malloc(len))) {
1629 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1633 avio_read(pb, attachment, len);
1635 ost = new_attachment_stream(o, oc, -1);
1636 ost->stream_copy = 0;
1637 ost->attachment_filename = o->attachments[i];
1638 ost->st->codec->extradata = attachment;
1639 ost->st->codec->extradata_size = len;
1641 p = strrchr(o->attachments[i], '/');
1642 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1646 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1647 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1650 output_files[nb_output_files - 1]->ctx = oc;
1651 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1652 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1653 if (o->recording_time != INT64_MAX)
1654 oc->duration = o->recording_time;
1655 output_files[nb_output_files - 1]->start_time = o->start_time;
1656 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1657 output_files[nb_output_files - 1]->shortest = o->shortest;
1658 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1660 /* check filename in case of an image number is expected */
1661 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1662 if (!av_filename_number_test(oc->filename)) {
1663 print_error(oc->filename, AVERROR(EINVAL));
1668 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1669 /* test if it already exists to avoid losing precious files */
1670 assert_file_overwrite(filename);
1673 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1674 &oc->interrupt_callback,
1675 &output_files[nb_output_files - 1]->opts)) < 0) {
1676 print_error(filename, err);
1681 if (o->mux_preload) {
1683 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1684 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1686 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1689 for (i = 0; i < o->nb_metadata_map; i++) {
1691 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1693 if (in_file_index >= nb_input_files) {
1694 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1697 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1701 if (o->chapters_input_file >= nb_input_files) {
1702 if (o->chapters_input_file == INT_MAX) {
1703 /* copy chapters from the first input file that has them*/
1704 o->chapters_input_file = -1;
1705 for (i = 0; i < nb_input_files; i++)
1706 if (input_files[i]->ctx->nb_chapters) {
1707 o->chapters_input_file = i;
1711 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1712 o->chapters_input_file);
1716 if (o->chapters_input_file >= 0)
1717 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1718 !o->metadata_chapters_manual);
1720 /* copy global metadata by default */
1721 if (!o->metadata_global_manual && nb_input_files){
1722 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1723 AV_DICT_DONT_OVERWRITE);
1724 if(o->recording_time != INT64_MAX)
1725 av_dict_set(&oc->metadata, "duration", NULL, 0);
1726 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1728 if (!o->metadata_streams_manual)
1729 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1731 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1733 ist = input_streams[output_streams[i]->source_index];
1734 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1737 /* process manually set metadata */
1738 for (i = 0; i < o->nb_metadata; i++) {
1741 const char *stream_spec;
1742 int index = 0, j, ret = 0;
1744 val = strchr(o->metadata[i].u.str, '=');
1746 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1747 o->metadata[i].u.str);
1752 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1754 for (j = 0; j < oc->nb_streams; j++) {
1755 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1756 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1767 if (index < 0 || index >= oc->nb_chapters) {
1768 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1771 m = &oc->chapters[index]->metadata;
1774 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1777 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1781 reset_options(o, 0);
1784 static int opt_target(void *optctx, const char *opt, const char *arg)
1786 OptionsContext *o = optctx;
1787 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1788 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1790 if (!strncmp(arg, "pal-", 4)) {
1793 } else if (!strncmp(arg, "ntsc-", 5)) {
1796 } else if (!strncmp(arg, "film-", 5)) {
1800 /* Try to determine PAL/NTSC by peeking in the input files */
1801 if (nb_input_files) {
1803 for (j = 0; j < nb_input_files; j++) {
1804 for (i = 0; i < input_files[j]->nb_streams; i++) {
1805 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1806 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1808 fr = c->time_base.den * 1000 / c->time_base.num;
1812 } else if ((fr == 29970) || (fr == 23976)) {
1817 if (norm != UNKNOWN)
1821 if (norm != UNKNOWN)
1822 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1825 if (norm == UNKNOWN) {
1826 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1827 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1828 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1832 if (!strcmp(arg, "vcd")) {
1833 opt_video_codec(o, "c:v", "mpeg1video");
1834 opt_audio_codec(o, "c:a", "mp2");
1835 parse_option(o, "f", "vcd", options);
1837 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1838 parse_option(o, "r", frame_rates[norm], options);
1839 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1841 opt_default(NULL, "b:v", "1150000");
1842 opt_default(NULL, "maxrate", "1150000");
1843 opt_default(NULL, "minrate", "1150000");
1844 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1846 opt_default(NULL, "b:a", "224000");
1847 parse_option(o, "ar", "44100", options);
1848 parse_option(o, "ac", "2", options);
1850 opt_default(NULL, "packetsize", "2324");
1851 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1853 /* We have to offset the PTS, so that it is consistent with the SCR.
1854 SCR starts at 36000, but the first two packs contain only padding
1855 and the first pack from the other stream, respectively, may also have
1856 been written before.
1857 So the real data starts at SCR 36000+3*1200. */
1858 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1859 } else if (!strcmp(arg, "svcd")) {
1861 opt_video_codec(o, "c:v", "mpeg2video");
1862 opt_audio_codec(o, "c:a", "mp2");
1863 parse_option(o, "f", "svcd", options);
1865 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1866 parse_option(o, "r", frame_rates[norm], options);
1867 parse_option(o, "pix_fmt", "yuv420p", options);
1868 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1870 opt_default(NULL, "b:v", "2040000");
1871 opt_default(NULL, "maxrate", "2516000");
1872 opt_default(NULL, "minrate", "0"); // 1145000;
1873 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1874 opt_default(NULL, "scan_offset", "1");
1876 opt_default(NULL, "b:a", "224000");
1877 parse_option(o, "ar", "44100", options);
1879 opt_default(NULL, "packetsize", "2324");
1881 } else if (!strcmp(arg, "dvd")) {
1883 opt_video_codec(o, "c:v", "mpeg2video");
1884 opt_audio_codec(o, "c:a", "ac3");
1885 parse_option(o, "f", "dvd", options);
1887 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1888 parse_option(o, "r", frame_rates[norm], options);
1889 parse_option(o, "pix_fmt", "yuv420p", options);
1890 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1892 opt_default(NULL, "b:v", "6000000");
1893 opt_default(NULL, "maxrate", "9000000");
1894 opt_default(NULL, "minrate", "0"); // 1500000;
1895 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1897 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1898 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1900 opt_default(NULL, "b:a", "448000");
1901 parse_option(o, "ar", "48000", options);
1903 } else if (!strncmp(arg, "dv", 2)) {
1905 parse_option(o, "f", "dv", options);
1907 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1908 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1909 norm == PAL ? "yuv420p" : "yuv411p", options);
1910 parse_option(o, "r", frame_rates[norm], options);
1912 parse_option(o, "ar", "48000", options);
1913 parse_option(o, "ac", "2", options);
1916 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1917 return AVERROR(EINVAL);
1922 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1924 av_free (vstats_filename);
1925 vstats_filename = av_strdup (arg);
1929 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1932 time_t today2 = time(NULL);
1933 struct tm *today = localtime(&today2);
1935 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1937 return opt_vstats_file(NULL, opt, filename);
1940 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1942 OptionsContext *o = optctx;
1943 return parse_option(o, "frames:v", arg, options);
1946 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1948 OptionsContext *o = optctx;
1949 return parse_option(o, "frames:a", arg, options);
1952 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1954 OptionsContext *o = optctx;
1955 return parse_option(o, "frames:d", arg, options);
1958 static int opt_preset(void *optctx, const char *opt, const char *arg)
1960 OptionsContext *o = optctx;
1962 char filename[1000], line[1000], tmp_line[1000];
1963 const char *codec_name = NULL;
1967 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1969 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1970 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1971 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1973 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1977 while (fgets(line, sizeof(line), f)) {
1978 char *key = tmp_line, *value, *endptr;
1980 if (strcspn(line, "#\n\r") == 0)
1982 strcpy(tmp_line, line);
1983 if (!av_strtok(key, "=", &value) ||
1984 !av_strtok(value, "\r\n", &endptr)) {
1985 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1988 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1990 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1991 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1992 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1993 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1994 else if (opt_default(NULL, key, value) < 0) {
1995 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1996 filename, line, key, value);
2006 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2008 OptionsContext *o = optctx;
2009 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2010 int ret = parse_option(o, s, arg, options);
2015 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2017 OptionsContext *o = optctx;
2018 if(!strcmp(opt, "b")){
2019 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2020 return parse_option(o, "b:v", arg, options);
2022 return opt_default(optctx, opt, arg);
2025 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2027 OptionsContext *o = optctx;
2030 if(!strcmp(opt, "qscale")){
2031 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2032 return parse_option(o, "q:v", arg, options);
2034 s = av_asprintf("q%s", opt + 6);
2035 ret = parse_option(o, s, arg, options);
2040 static int opt_profile(void *optctx, const char *opt, const char *arg)
2042 OptionsContext *o = optctx;
2043 if(!strcmp(opt, "profile")){
2044 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2045 return parse_option(o, "profile:v", arg, options);
2047 return opt_default(optctx, opt, arg);
2051 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2053 OptionsContext *o = optctx;
2054 return parse_option(o, "filter:v", arg, options);
2057 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2059 OptionsContext *o = optctx;
2060 return parse_option(o, "filter:a", arg, options);
2063 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2065 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2066 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2067 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2068 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2070 if (video_sync_method == VSYNC_AUTO)
2071 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2075 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2077 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2082 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2084 OptionsContext *o = optctx;
2085 char *tcr = av_asprintf("timecode=%s", arg);
2086 int ret = parse_option(o, "metadata:g", tcr, options);
2088 ret = opt_default(optctx, "gop_timecode", arg);
2093 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2095 OptionsContext *o = optctx;
2096 char layout_str[32];
2099 int ret, channels, ac_str_size;
2102 layout = av_get_channel_layout(arg);
2104 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2105 return AVERROR(EINVAL);
2107 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2108 ret = opt_default(NULL, opt, layout_str);
2112 /* set 'ac' option based on channel layout */
2113 channels = av_get_channel_layout_nb_channels(layout);
2114 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2115 stream_str = strchr(opt, ':');
2116 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2117 ac_str = av_mallocz(ac_str_size);
2119 return AVERROR(ENOMEM);
2120 av_strlcpy(ac_str, "ac", 3);
2122 av_strlcat(ac_str, stream_str, ac_str_size);
2123 ret = parse_option(o, ac_str, layout_str, options);
2129 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2131 OptionsContext *o = optctx;
2132 return parse_option(o, "q:a", arg, options);
2135 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2137 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2138 &nb_filtergraphs, nb_filtergraphs + 1);
2139 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2140 return AVERROR(ENOMEM);
2141 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2142 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2146 void show_help_default(const char *opt, const char *arg)
2148 /* per-file options have at least one of those set */
2149 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2150 int show_advanced = 0, show_avoptions = 0;
2153 if (!strcmp(opt, "long"))
2155 else if (!strcmp(opt, "full"))
2156 show_advanced = show_avoptions = 1;
2158 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2163 printf("Getting help:\n"
2164 " -h -- print basic options\n"
2165 " -h long -- print more options\n"
2166 " -h full -- print all options (including all format and codec specific options, very long)\n"
2167 " See man %s for detailed description of the options.\n"
2168 "\n", program_name);
2170 show_help_options(options, "Print help / information / capabilities:",
2173 show_help_options(options, "Global options (affect whole program "
2174 "instead of just one file:",
2175 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2177 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2178 per_file | OPT_EXIT, 0);
2180 show_help_options(options, "Per-file main options:", 0,
2181 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2182 OPT_EXIT, per_file);
2184 show_help_options(options, "Advanced per-file options:",
2185 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2187 show_help_options(options, "Video options:",
2188 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2190 show_help_options(options, "Advanced Video options:",
2191 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2193 show_help_options(options, "Audio options:",
2194 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2196 show_help_options(options, "Advanced Audio options:",
2197 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2198 show_help_options(options, "Subtitle options:",
2199 OPT_SUBTITLE, 0, 0);
2202 if (show_avoptions) {
2203 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2204 show_help_children(avcodec_get_class(), flags);
2205 show_help_children(avformat_get_class(), flags);
2206 show_help_children(sws_get_class(), flags);
2207 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2208 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2212 void show_usage(void)
2214 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2215 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2216 av_log(NULL, AV_LOG_INFO, "\n");
2220 static int opt_progress(void *optctx, const char *opt, const char *arg)
2222 AVIOContext *avio = NULL;
2225 if (!strcmp(arg, "-"))
2227 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2229 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2230 arg, av_err2str(ret));
2233 progress_avio = avio;
2237 #define OFFSET(x) offsetof(OptionsContext, x)
2238 const OptionDef options[] = {
2240 #include "cmdutils_common_opts.h"
2241 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2242 "force format", "fmt" },
2243 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2244 "input file name", "filename" },
2245 { "y", OPT_BOOL, { &file_overwrite },
2246 "overwrite output files" },
2247 { "n", OPT_BOOL, { &no_file_overwrite },
2248 "do not overwrite output files" },
2249 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2250 "codec name", "codec" },
2251 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2252 "codec name", "codec" },
2253 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2254 "preset name", "preset" },
2255 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2256 "set input stream mapping",
2257 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2258 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2259 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2260 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2261 "set metadata information of outfile from infile",
2262 "outfile[,metadata]:infile[,metadata]" },
2263 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2264 "set chapters mapping", "input_file_index" },
2265 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2266 "record or transcode \"duration\" seconds of audio/video",
2268 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2269 "set the limit file size in bytes", "limit_size" },
2270 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2271 "set the start time offset", "time_off" },
2272 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2273 "set the input ts offset", "time_off" },
2274 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2275 "set the input ts scale", "scale" },
2276 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2277 "set the recording timestamp ('now' to set the current time)", "time" },
2278 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2279 "add metadata", "string=string" },
2280 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2281 "set the number of data frames to record", "number" },
2282 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2283 "add timings for benchmarking" },
2284 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2285 "add timings for each task" },
2286 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2287 "write program-readable progress information", "url" },
2288 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2289 "enable or disable interaction on standard input" },
2290 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2291 "set max runtime in seconds", "limit" },
2292 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2293 "dump each input packet" },
2294 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2295 "when dumping packets, also dump the payload" },
2296 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2297 "read input at native frame rate", "" },
2298 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2299 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2300 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2301 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2302 "video sync method", "" },
2303 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2304 "audio sync method", "" },
2305 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2306 "audio drift threshold", "threshold" },
2307 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2308 "copy timestamps" },
2309 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2310 "copy input stream time base when stream copying", "mode" },
2311 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2312 "finish encoding within shortest input" },
2313 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2314 "timestamp discontinuity delta threshold", "threshold" },
2315 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2316 "timestamp error delta threshold", "threshold" },
2317 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2318 "exit on error", "error" },
2319 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2320 "copy initial non-keyframes" },
2321 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2322 "set the number of frames to record", "number" },
2323 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2324 "force codec tag/fourcc", "fourcc/tag" },
2325 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2326 "use fixed quality scale (VBR)", "q" },
2327 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2328 "use fixed quality scale (VBR)", "q" },
2329 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2330 "set profile", "profile" },
2331 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2332 "set stream filterchain", "filter_list" },
2333 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2334 "create a complex filtergraph", "graph_description" },
2335 { "stats", OPT_BOOL, { &print_stats },
2336 "print progress report during encoding", },
2337 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2338 "add an attachment to the output file", "filename" },
2339 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2340 "extract an attachment into a file", "filename" },
2341 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2342 "print timestamp debugging info" },
2345 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2346 "set the number of video frames to record", "number" },
2347 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2348 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2349 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2350 "set frame size (WxH or abbreviation)", "size" },
2351 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2352 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2353 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2354 "set pixel format", "format" },
2355 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2356 "set the number of bits per raw sample", "number" },
2357 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2358 "Removed, use the crop filter instead", "size" },
2359 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2360 "Removed, use the crop filter instead", "size" },
2361 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2362 "Removed, use the crop filter instead", "size" },
2363 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2364 "Removed, use the crop filter instead", "size" },
2365 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2366 "Removed, use the pad filter instead", "size" },
2367 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2368 "Removed, use the pad filter instead", "size" },
2369 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2370 "Removed, use the pad filter instead", "size" },
2371 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2372 "Removed, use the pad filter instead", "size" },
2373 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2374 "Removed, use the pad filter instead", "color" },
2375 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2376 "deprecated use -g 1" },
2377 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2379 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2380 "discard threshold", "n" },
2381 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2382 "rate control override for specific intervals", "override" },
2383 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2384 "force video codec ('copy' to copy stream)", "codec" },
2385 { "sameq", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &same_quant },
2386 "use same quantizer as source (implies VBR)" },
2387 { "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
2388 "use same quantizer as source (implies VBR)" },
2389 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2390 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2391 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2392 "select the pass number (1 to 3)", "n" },
2393 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2394 "select two pass log file name prefix", "prefix" },
2395 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2396 "this option is deprecated, use the yadif filter instead" },
2397 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2398 "calculate PSNR of compressed frames" },
2399 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2400 "dump video coding statistics to file" },
2401 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2402 "dump video coding statistics to file", "file" },
2403 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2404 "video filters", "filter list" },
2405 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2406 "specify intra matrix coeffs", "matrix" },
2407 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2408 "specify inter matrix coeffs", "matrix" },
2409 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2410 "top=1/bottom=0/auto=-1 field first", "" },
2411 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2412 "intra_dc_precision", "precision" },
2413 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2414 "force video tag/fourcc", "fourcc/tag" },
2415 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2416 "show QP histogram" },
2417 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2418 "force the selected framerate, disable the best supported framerate selection" },
2419 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2420 "set the value of an outfile streamid", "streamIndex:value" },
2421 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2422 { .off = OFFSET(forced_key_frames) },
2423 "force key frames at specified timestamps", "timestamps" },
2424 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2425 "video bitrate (please use -b:v)", "bitrate" },
2428 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2429 "set the number of audio frames to record", "number" },
2430 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2431 "set audio quality (codec-specific)", "quality", },
2432 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2433 "set audio sampling rate (in Hz)", "rate" },
2434 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2435 "set number of audio channels", "channels" },
2436 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2438 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2439 "force audio codec ('copy' to copy stream)", "codec" },
2440 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2441 "force audio tag/fourcc", "fourcc/tag" },
2442 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2443 "change audio volume (256=normal)" , "volume" },
2444 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2445 "set sample format", "format" },
2446 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2447 "set channel layout", "layout" },
2448 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2449 "audio filters", "filter list" },
2451 /* subtitle options */
2452 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2453 "disable subtitle" },
2454 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2455 "force subtitle codec ('copy' to copy stream)", "codec" },
2456 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2457 , "force subtitle tag/fourcc", "fourcc/tag" },
2458 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2459 "fix subtitles duration" },
2462 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2463 "deprecated, use -channel", "channel" },
2464 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2465 "deprecated, use -standard", "standard" },
2466 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2469 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2470 "set the maximum demux-decode delay", "seconds" },
2471 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2472 "set the initial demux-decode delay", "seconds" },
2474 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2475 "A comma-separated list of bitstream filters", "bitstream_filters" },
2476 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2477 "deprecated", "audio bitstream_filters" },
2478 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2479 "deprecated", "video bitstream_filters" },
2481 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2482 "set the audio options to the indicated preset", "preset" },
2483 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2484 "set the video options to the indicated preset", "preset" },
2485 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2486 "set the subtitle options to the indicated preset", "preset" },
2487 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2488 "set options from indicated preset file", "filename" },
2489 /* data codec support */
2490 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2491 "force data codec ('copy' to copy stream)", "codec" },
2492 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2495 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2496 "generic catch all option", "" },