2 * avconv option parsing
4 * This file is part of Libav.
6 * Libav 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 * Libav 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 Libav; 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 char *pass_logfilename_prefix = NULL;
58 char *vstats_filename;
60 float audio_drift_threshold = 0.1;
61 float dts_delta_threshold = 10;
63 int audio_volume = 256;
64 int audio_sync_method = 0;
65 int video_sync_method = VSYNC_AUTO;
66 int do_deinterlace = 0;
73 int exit_on_error = 0;
78 static int file_overwrite = 0;
79 static int video_discard = 0;
80 static int intra_dc_precision = 8;
81 static int do_pass = 0;
82 static int using_stdin = 0;
83 static int input_sync;
85 void reset_options(OptionsContext *o)
87 const OptionDef *po = options;
90 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
92 void *dst = (uint8_t*)o + po->u.off;
94 if (po->flags & OPT_SPEC) {
95 SpecifierOpt **so = dst;
96 int i, *count = (int*)(so + 1);
97 for (i = 0; i < *count; i++) {
98 av_freep(&(*so)[i].specifier);
99 if (po->flags & OPT_STRING)
100 av_freep(&(*so)[i].u.str);
104 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
109 for (i = 0; i < o->nb_stream_maps; i++)
110 av_freep(&o->stream_maps[i].linklabel);
111 av_freep(&o->stream_maps);
112 av_freep(&o->meta_data_maps);
113 av_freep(&o->streamid_map);
115 memset(o, 0, sizeof(*o));
117 o->mux_max_delay = 0.7;
118 o->recording_time = INT64_MAX;
119 o->limit_filesize = UINT64_MAX;
120 o->chapters_input_file = INT_MAX;
127 static double parse_frame_aspect_ratio(const char *arg)
134 p = strchr(arg, ':');
136 x = strtol(arg, &end, 10);
138 y = strtol(end + 1, &end, 10);
140 ar = (double)x / (double)y;
142 ar = strtod(arg, NULL);
145 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
151 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
153 OptionsContext *o = optctx;
154 return parse_option(o, "codec:a", arg, options);
157 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
159 OptionsContext *o = optctx;
160 return parse_option(o, "codec:v", arg, options);
163 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
165 OptionsContext *o = optctx;
166 return parse_option(o, "codec:s", arg, options);
169 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
171 OptionsContext *o = optctx;
172 return parse_option(o, "codec:d", arg, options);
175 static int opt_map(void *optctx, const char *opt, const char *arg)
177 OptionsContext *o = optctx;
179 int i, negative = 0, file_idx;
180 int sync_file_idx = -1, sync_stream_idx;
188 map = av_strdup(arg);
190 /* parse sync stream first, just pick first matching stream */
191 if (sync = strchr(map, ',')) {
193 sync_file_idx = strtol(sync + 1, &sync, 0);
194 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
195 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
200 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
201 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
202 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
206 if (i == input_files[sync_file_idx]->nb_streams) {
207 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
208 "match any streams.\n", arg);
215 /* this mapping refers to lavfi output */
216 const char *c = map + 1;
217 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
218 &o->nb_stream_maps, o->nb_stream_maps + 1);
219 m = &o->stream_maps[o->nb_stream_maps - 1];
220 m->linklabel = av_get_token(&c, "]");
222 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
226 file_idx = strtol(map, &p, 0);
227 if (file_idx >= nb_input_files || file_idx < 0) {
228 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
232 /* disable some already defined maps */
233 for (i = 0; i < o->nb_stream_maps; i++) {
234 m = &o->stream_maps[i];
235 if (file_idx == m->file_index &&
236 check_stream_specifier(input_files[m->file_index]->ctx,
237 input_files[m->file_index]->ctx->streams[m->stream_index],
238 *p == ':' ? p + 1 : p) > 0)
242 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
243 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
244 *p == ':' ? p + 1 : p) <= 0)
246 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
247 &o->nb_stream_maps, o->nb_stream_maps + 1);
248 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->file_index = file_idx;
253 if (sync_file_idx >= 0) {
254 m->sync_file_index = sync_file_idx;
255 m->sync_stream_index = sync_stream_idx;
257 m->sync_file_index = file_idx;
258 m->sync_stream_index = i;
264 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
272 static int opt_attach(void *optctx, const char *opt, const char *arg)
274 OptionsContext *o = optctx;
275 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
276 &o->nb_attachments, o->nb_attachments + 1);
277 o->attachments[o->nb_attachments - 1] = arg;
282 * Parse a metadata specifier in arg.
283 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
284 * @param index for type c/p, chapter/program index is written here
285 * @param stream_spec for type s, the stream specifier is written here
287 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
295 if (*(++arg) && *arg != ':') {
296 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
299 *stream_spec = *arg == ':' ? arg + 1 : "";
304 *index = strtol(++arg, NULL, 0);
307 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
314 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
316 AVDictionary **meta_in = NULL;
317 AVDictionary **meta_out;
319 char type_in, type_out;
320 const char *istream_spec = NULL, *ostream_spec = NULL;
321 int idx_in = 0, idx_out = 0;
323 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
324 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
326 if (type_in == 'g' || type_out == 'g')
327 o->metadata_global_manual = 1;
328 if (type_in == 's' || type_out == 's')
329 o->metadata_streams_manual = 1;
330 if (type_in == 'c' || type_out == 'c')
331 o->metadata_chapters_manual = 1;
333 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
334 if ((index) < 0 || (index) >= (nb_elems)) {\
335 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
340 #define SET_DICT(type, meta, context, index)\
343 meta = &context->metadata;\
346 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
347 meta = &context->chapters[index]->metadata;\
350 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
351 meta = &context->programs[index]->metadata;\
353 default: av_assert0(0);\
356 SET_DICT(type_in, meta_in, ic, idx_in);
357 SET_DICT(type_out, meta_out, oc, idx_out);
359 /* for input streams choose first matching stream */
360 if (type_in == 's') {
361 for (i = 0; i < ic->nb_streams; i++) {
362 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
363 meta_in = &ic->streams[i]->metadata;
369 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
374 if (type_out == 's') {
375 for (i = 0; i < oc->nb_streams; i++) {
376 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
377 meta_out = &oc->streams[i]->metadata;
378 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
383 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
388 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
390 const AVCodecDescriptor *desc;
391 const char *codec_string = encoder ? "encoder" : "decoder";
395 avcodec_find_encoder_by_name(name) :
396 avcodec_find_decoder_by_name(name);
398 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
399 codec = encoder ? avcodec_find_encoder(desc->id) :
400 avcodec_find_decoder(desc->id);
402 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
403 codec_string, codec->name, desc->name);
407 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
410 if (codec->type != type) {
411 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
417 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
419 char *codec_name = NULL;
421 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
423 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
424 st->codec->codec_id = codec->id;
427 return avcodec_find_decoder(st->codec->codec_id);
431 * Add all the streams from the given input file to the global
432 * list of input streams.
434 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
438 for (i = 0; i < ic->nb_streams; i++) {
439 AVStream *st = ic->streams[i];
440 AVCodecContext *dec = st->codec;
441 InputStream *ist = av_mallocz(sizeof(*ist));
442 char *framerate = NULL;
447 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
448 input_streams[nb_input_streams - 1] = ist;
451 ist->file_index = nb_input_files;
453 st->discard = AVDISCARD_ALL;
454 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
457 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
459 ist->dec = choose_decoder(o, ic, st);
461 switch (dec->codec_type) {
462 case AVMEDIA_TYPE_VIDEO:
463 ist->resample_height = dec->height;
464 ist->resample_width = dec->width;
465 ist->resample_pix_fmt = dec->pix_fmt;
467 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
468 if (framerate && av_parse_video_rate(&ist->framerate,
470 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
476 case AVMEDIA_TYPE_AUDIO:
477 guess_input_channel_layout(ist);
479 ist->resample_sample_fmt = dec->sample_fmt;
480 ist->resample_sample_rate = dec->sample_rate;
481 ist->resample_channels = dec->channels;
482 ist->resample_channel_layout = dec->channel_layout;
485 case AVMEDIA_TYPE_DATA:
486 case AVMEDIA_TYPE_SUBTITLE:
487 case AVMEDIA_TYPE_ATTACHMENT:
488 case AVMEDIA_TYPE_UNKNOWN:
496 static void assert_file_overwrite(const char *filename)
498 if (!file_overwrite &&
499 (strchr(filename, ':') == NULL || filename[1] == ':' ||
500 av_strstart(filename, "file:", NULL))) {
501 if (avio_check(filename, 0) == 0) {
503 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
506 fprintf(stderr, "Not overwriting - exiting\n");
511 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
518 static void dump_attachment(AVStream *st, const char *filename)
521 AVIOContext *out = NULL;
522 AVDictionaryEntry *e;
524 if (!st->codec->extradata_size) {
525 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
526 nb_input_files - 1, st->index);
529 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
532 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
533 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
537 assert_file_overwrite(filename);
539 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
540 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
545 avio_write(out, st->codec->extradata, st->codec->extradata_size);
550 static int opt_input_file(void *optctx, const char *opt, const char *filename)
552 OptionsContext *o = optctx;
554 AVInputFormat *file_iformat = NULL;
559 int orig_nb_streams; // number of streams before avformat_find_stream_info
562 if (!(file_iformat = av_find_input_format(o->format))) {
563 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
568 if (!strcmp(filename, "-"))
571 using_stdin |= !strncmp(filename, "pipe:", 5) ||
572 !strcmp(filename, "/dev/stdin");
574 /* get default parameters from command line */
575 ic = avformat_alloc_context();
577 print_error(filename, AVERROR(ENOMEM));
580 if (o->nb_audio_sample_rate) {
581 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
582 av_dict_set(&format_opts, "sample_rate", buf, 0);
584 if (o->nb_audio_channels) {
585 /* because we set audio_channels based on both the "ac" and
586 * "channel_layout" options, we need to check that the specified
587 * demuxer actually has the "channels" option before setting it */
588 if (file_iformat && file_iformat->priv_class &&
589 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
590 AV_OPT_SEARCH_FAKE_OBJ)) {
591 snprintf(buf, sizeof(buf), "%d",
592 o->audio_channels[o->nb_audio_channels - 1].u.i);
593 av_dict_set(&format_opts, "channels", buf, 0);
596 if (o->nb_frame_rates) {
597 /* set the format-level framerate option;
598 * this is important for video grabbers, e.g. x11 */
599 if (file_iformat && file_iformat->priv_class &&
600 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
601 AV_OPT_SEARCH_FAKE_OBJ)) {
602 av_dict_set(&format_opts, "framerate",
603 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
606 if (o->nb_frame_sizes) {
607 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
609 if (o->nb_frame_pix_fmts)
610 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
612 ic->flags |= AVFMT_FLAG_NONBLOCK;
613 ic->interrupt_callback = int_cb;
615 /* open the input file with generic libav function */
616 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
618 print_error(filename, err);
621 assert_avoptions(format_opts);
623 /* apply forced codec ids */
624 for (i = 0; i < ic->nb_streams; i++)
625 choose_decoder(o, ic, ic->streams[i]);
627 /* Set AVCodecContext options for avformat_find_stream_info */
628 opts = setup_find_stream_info_opts(ic, codec_opts);
629 orig_nb_streams = ic->nb_streams;
631 /* If not enough info to get the stream parameters, we decode the
632 first frames to get it. (used in mpeg case for example) */
633 ret = avformat_find_stream_info(ic, opts);
635 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
636 avformat_close_input(&ic);
640 timestamp = o->start_time;
641 /* add the stream start time */
642 if (ic->start_time != AV_NOPTS_VALUE)
643 timestamp += ic->start_time;
645 /* if seeking requested, we execute it */
646 if (o->start_time != 0) {
647 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
649 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
650 filename, (double)timestamp / AV_TIME_BASE);
654 /* update the current parameters so that they match the one of the input stream */
655 add_input_streams(o, ic);
657 /* dump the file content */
658 av_dump_format(ic, nb_input_files, filename, 0);
660 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
661 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
664 input_files[nb_input_files - 1]->ctx = ic;
665 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
666 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
667 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
668 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
670 for (i = 0; i < o->nb_dump_attachment; i++) {
673 for (j = 0; j < ic->nb_streams; j++) {
674 AVStream *st = ic->streams[j];
676 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
677 dump_attachment(st, o->dump_attachment[i].u.str);
681 for (i = 0; i < orig_nb_streams; i++)
682 av_dict_free(&opts[i]);
689 static uint8_t *get_line(AVIOContext *s)
695 if (avio_open_dyn_buf(&line) < 0) {
696 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
700 while ((c = avio_r8(s)) && c != '\n')
703 avio_close_dyn_buf(line, &buf);
708 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
712 const char *base[3] = { getenv("AVCONV_DATADIR"),
717 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
721 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
722 i != 1 ? "" : "/.avconv", codec_name, preset_name);
723 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
726 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
727 i != 1 ? "" : "/.avconv", preset_name);
728 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
734 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
736 char *codec_name = NULL;
738 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
740 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
741 NULL, ost->st->codec->codec_type);
742 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
743 } else if (!strcmp(codec_name, "copy"))
744 ost->stream_copy = 1;
746 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
747 ost->st->codec->codec_id = ost->enc->id;
751 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
754 AVStream *st = avformat_new_stream(oc, NULL);
755 int idx = oc->nb_streams - 1, ret = 0;
756 char *bsf = NULL, *next, *codec_tag = NULL;
757 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
759 char *buf = NULL, *arg = NULL, *preset = NULL;
760 AVIOContext *s = NULL;
763 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
767 if (oc->nb_streams - 1 < o->nb_streamid_map)
768 st->id = o->streamid_map[oc->nb_streams - 1];
770 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
771 nb_output_streams + 1);
772 if (!(ost = av_mallocz(sizeof(*ost))))
774 output_streams[nb_output_streams - 1] = ost;
776 ost->file_index = nb_output_files;
779 st->codec->codec_type = type;
780 choose_encoder(o, oc, ost);
782 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
785 avcodec_get_context_defaults3(st->codec, ost->enc);
786 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
788 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
789 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
792 if (!buf[0] || buf[0] == '#') {
796 if (!(arg = strchr(buf, '='))) {
797 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
801 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
803 } while (!s->eof_reached);
807 av_log(NULL, AV_LOG_FATAL,
808 "Preset %s specified for stream %d:%d, but could not be opened.\n",
809 preset, ost->file_index, ost->index);
813 ost->max_frames = INT64_MAX;
814 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
816 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
818 if (next = strchr(bsf, ','))
820 if (!(bsfc = av_bitstream_filter_init(bsf))) {
821 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
825 bsfc_prev->next = bsfc;
827 ost->bitstream_filters = bsfc;
833 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
835 uint32_t tag = strtol(codec_tag, &next, 0);
837 tag = AV_RL32(codec_tag);
838 st->codec->codec_tag = tag;
841 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
842 if (qscale >= 0 || same_quant) {
843 st->codec->flags |= CODEC_FLAG_QSCALE;
844 st->codec->global_quality = FF_QP2LAMBDA * qscale;
847 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
848 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
850 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
852 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
857 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
867 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
874 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
878 AVCodecContext *video_enc;
880 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
882 video_enc = st->codec;
884 if (!ost->stream_copy) {
885 const char *p = NULL;
886 char *frame_rate = NULL, *frame_size = NULL;
887 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
888 char *intra_matrix = NULL, *inter_matrix = NULL;
889 const char *filters = "null";
892 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
893 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
894 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
898 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
899 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
900 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
904 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
905 if (frame_aspect_ratio)
906 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
908 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
909 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
910 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
913 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
915 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
917 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
918 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
921 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
923 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
925 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
926 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
929 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
932 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
933 for (i = 0; p; i++) {
935 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
937 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
940 video_enc->rc_override =
941 av_realloc(video_enc->rc_override,
942 sizeof(RcOverride) * (i + 1));
943 video_enc->rc_override[i].start_frame = start;
944 video_enc->rc_override[i].end_frame = end;
946 video_enc->rc_override[i].qscale = q;
947 video_enc->rc_override[i].quality_factor = 1.0;
950 video_enc->rc_override[i].qscale = 0;
951 video_enc->rc_override[i].quality_factor = -q/100.0;
956 video_enc->rc_override_count = i;
957 if (!video_enc->rc_initial_buffer_occupancy)
958 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
959 video_enc->intra_dc_precision = intra_dc_precision - 8;
964 video_enc->flags |= CODEC_FLAG_PASS1;
966 video_enc->flags |= CODEC_FLAG_PASS2;
970 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
971 if (ost->forced_keyframes)
972 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
974 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
976 ost->top_field_first = -1;
977 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
979 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
980 ost->avfilter = av_strdup(filters);
982 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
988 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
992 AVCodecContext *audio_enc;
994 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
997 audio_enc = st->codec;
998 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1000 if (!ost->stream_copy) {
1001 char *sample_fmt = NULL;
1002 const char *filters = "anull";
1004 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1006 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1008 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1009 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1013 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1015 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1016 ost->avfilter = av_strdup(filters);
1022 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1026 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1027 if (!ost->stream_copy) {
1028 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1035 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1037 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1038 ost->stream_copy = 1;
1042 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1046 AVCodecContext *subtitle_enc;
1048 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1050 subtitle_enc = st->codec;
1052 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1057 /* arg format is "output-stream-index:streamid-value". */
1058 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1060 OptionsContext *o = optctx;
1065 av_strlcpy(idx_str, arg, sizeof(idx_str));
1066 p = strchr(idx_str, ':');
1068 av_log(NULL, AV_LOG_FATAL,
1069 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1074 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1075 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1076 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1080 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1082 AVFormatContext *is = ifile->ctx;
1083 AVFormatContext *os = ofile->ctx;
1086 for (i = 0; i < is->nb_chapters; i++) {
1087 AVChapter *in_ch = is->chapters[i], *out_ch;
1088 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1089 AV_TIME_BASE_Q, in_ch->time_base);
1090 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1091 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1094 if (in_ch->end < ts_off)
1096 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1099 out_ch = av_mallocz(sizeof(AVChapter));
1101 return AVERROR(ENOMEM);
1103 out_ch->id = in_ch->id;
1104 out_ch->time_base = in_ch->time_base;
1105 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1106 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1109 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1112 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
1114 return AVERROR(ENOMEM);
1115 os->chapters[os->nb_chapters - 1] = out_ch;
1120 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1121 AVFormatContext *oc)
1125 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1126 ofilter->out_tmp->pad_idx)) {
1127 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1128 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1130 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1135 ost->source_index = -1;
1136 ost->filter = ofilter;
1140 if (ost->stream_copy) {
1141 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1142 "which is fed from a complex filtergraph. Filtering and streamcopy "
1143 "cannot be used together.\n", ost->file_index, ost->index);
1147 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1148 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1151 avfilter_inout_free(&ofilter->out_tmp);
1154 static int configure_complex_filters(void)
1158 for (i = 0; i < nb_filtergraphs; i++)
1159 if (!filtergraphs[i]->graph &&
1160 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1165 void opt_output_file(void *optctx, const char *filename)
1167 OptionsContext *o = optctx;
1168 AVFormatContext *oc;
1170 AVOutputFormat *file_oformat;
1174 if (configure_complex_filters() < 0) {
1175 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1179 if (!strcmp(filename, "-"))
1182 oc = avformat_alloc_context();
1184 print_error(filename, AVERROR(ENOMEM));
1189 file_oformat = av_guess_format(o->format, NULL, NULL);
1190 if (!file_oformat) {
1191 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1195 file_oformat = av_guess_format(NULL, filename, NULL);
1196 if (!file_oformat) {
1197 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1203 oc->oformat = file_oformat;
1204 oc->interrupt_callback = int_cb;
1205 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1207 /* create streams for all unlabeled output pads */
1208 for (i = 0; i < nb_filtergraphs; i++) {
1209 FilterGraph *fg = filtergraphs[i];
1210 for (j = 0; j < fg->nb_outputs; j++) {
1211 OutputFilter *ofilter = fg->outputs[j];
1213 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1216 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1217 ofilter->out_tmp->pad_idx)) {
1218 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1219 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1220 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1222 init_output_filter(ofilter, o, oc);
1226 if (!o->nb_stream_maps) {
1227 /* pick the "best" stream of each type */
1228 #define NEW_STREAM(type, index)\
1230 ost = new_ ## type ## _stream(o, oc);\
1231 ost->source_index = index;\
1232 ost->sync_ist = input_streams[index];\
1233 input_streams[index]->discard = 0;\
1234 input_streams[index]->st->discard = AVDISCARD_NONE;\
1237 /* video: highest resolution */
1238 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1239 int area = 0, idx = -1;
1240 for (i = 0; i < nb_input_streams; i++) {
1241 ist = input_streams[i];
1242 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1243 ist->st->codec->width * ist->st->codec->height > area) {
1244 area = ist->st->codec->width * ist->st->codec->height;
1248 NEW_STREAM(video, idx);
1251 /* audio: most channels */
1252 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1253 int channels = 0, idx = -1;
1254 for (i = 0; i < nb_input_streams; i++) {
1255 ist = input_streams[i];
1256 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1257 ist->st->codec->channels > channels) {
1258 channels = ist->st->codec->channels;
1262 NEW_STREAM(audio, idx);
1265 /* subtitles: pick first */
1266 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1267 for (i = 0; i < nb_input_streams; i++)
1268 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1269 NEW_STREAM(subtitle, i);
1273 /* do something with data? */
1275 for (i = 0; i < o->nb_stream_maps; i++) {
1276 StreamMap *map = &o->stream_maps[i];
1281 if (map->linklabel) {
1283 OutputFilter *ofilter = NULL;
1286 for (j = 0; j < nb_filtergraphs; j++) {
1287 fg = filtergraphs[j];
1288 for (k = 0; k < fg->nb_outputs; k++) {
1289 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1290 if (out && !strcmp(out->name, map->linklabel)) {
1291 ofilter = fg->outputs[k];
1298 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1299 "in any defined filter graph.\n", map->linklabel);
1302 init_output_filter(ofilter, o, oc);
1304 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1305 switch (ist->st->codec->codec_type) {
1306 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1307 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1308 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1309 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1310 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1312 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1313 map->file_index, map->stream_index);
1317 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1318 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1319 map->sync_stream_index];
1321 ist->st->discard = AVDISCARD_NONE;
1326 /* handle attached files */
1327 for (i = 0; i < o->nb_attachments; i++) {
1329 uint8_t *attachment;
1333 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1334 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1338 if ((len = avio_size(pb)) <= 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1343 if (!(attachment = av_malloc(len))) {
1344 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1348 avio_read(pb, attachment, len);
1350 ost = new_attachment_stream(o, oc);
1351 ost->stream_copy = 0;
1352 ost->source_index = -1;
1353 ost->attachment_filename = o->attachments[i];
1354 ost->st->codec->extradata = attachment;
1355 ost->st->codec->extradata_size = len;
1357 p = strrchr(o->attachments[i], '/');
1358 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1362 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1363 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1366 output_files[nb_output_files - 1]->ctx = oc;
1367 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1368 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1369 if (o->recording_time != INT64_MAX)
1370 oc->duration = o->recording_time;
1371 output_files[nb_output_files - 1]->start_time = o->start_time;
1372 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1373 output_files[nb_output_files - 1]->shortest = o->shortest;
1374 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1376 /* check filename in case of an image number is expected */
1377 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1378 if (!av_filename_number_test(oc->filename)) {
1379 print_error(oc->filename, AVERROR(EINVAL));
1384 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1385 /* test if it already exists to avoid losing precious files */
1386 assert_file_overwrite(filename);
1389 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1390 &oc->interrupt_callback,
1391 &output_files[nb_output_files - 1]->opts)) < 0) {
1392 print_error(filename, err);
1397 if (o->mux_preload) {
1399 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1400 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1402 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1403 oc->flags |= AVFMT_FLAG_NONBLOCK;
1406 for (i = 0; i < o->nb_metadata_map; i++) {
1408 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1410 if (in_file_index < 0)
1412 if (in_file_index >= nb_input_files) {
1413 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1416 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
1420 if (o->chapters_input_file >= nb_input_files) {
1421 if (o->chapters_input_file == INT_MAX) {
1422 /* copy chapters from the first input file that has them*/
1423 o->chapters_input_file = -1;
1424 for (i = 0; i < nb_input_files; i++)
1425 if (input_files[i]->ctx->nb_chapters) {
1426 o->chapters_input_file = i;
1430 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1431 o->chapters_input_file);
1435 if (o->chapters_input_file >= 0)
1436 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1437 !o->metadata_chapters_manual);
1439 /* copy global metadata by default */
1440 if (!o->metadata_global_manual && nb_input_files)
1441 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1442 AV_DICT_DONT_OVERWRITE);
1443 if (!o->metadata_streams_manual)
1444 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1446 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1448 ist = input_streams[output_streams[i]->source_index];
1449 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1452 /* process manually set metadata */
1453 for (i = 0; i < o->nb_metadata; i++) {
1456 const char *stream_spec;
1457 int index = 0, j, ret;
1459 val = strchr(o->metadata[i].u.str, '=');
1461 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1462 o->metadata[i].u.str);
1467 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1469 for (j = 0; j < oc->nb_streams; j++) {
1470 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1471 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1482 if (index < 0 || index >= oc->nb_chapters) {
1483 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1486 m = &oc->chapters[index]->metadata;
1489 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1492 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1499 /* same option as mencoder */
1500 static int opt_pass(const char *opt, const char *arg)
1502 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
1507 static int opt_target(void *optctx, const char *opt, const char *arg)
1509 OptionsContext *o = optctx;
1510 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1511 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1513 if (!strncmp(arg, "pal-", 4)) {
1516 } else if (!strncmp(arg, "ntsc-", 5)) {
1519 } else if (!strncmp(arg, "film-", 5)) {
1523 /* Try to determine PAL/NTSC by peeking in the input files */
1524 if (nb_input_files) {
1526 for (j = 0; j < nb_input_files; j++) {
1527 for (i = 0; i < input_files[j]->nb_streams; i++) {
1528 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1529 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1531 fr = c->time_base.den * 1000 / c->time_base.num;
1535 } else if ((fr == 29970) || (fr == 23976)) {
1540 if (norm != UNKNOWN)
1544 if (norm != UNKNOWN)
1545 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1548 if (norm == UNKNOWN) {
1549 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1550 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1551 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1555 if (!strcmp(arg, "vcd")) {
1556 opt_video_codec(o, "c:v", "mpeg1video");
1557 opt_audio_codec(o, "c:a", "mp2");
1558 parse_option(o, "f", "vcd", options);
1560 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1561 parse_option(o, "r", frame_rates[norm], options);
1562 opt_default("g", norm == PAL ? "15" : "18");
1564 opt_default("b", "1150000");
1565 opt_default("maxrate", "1150000");
1566 opt_default("minrate", "1150000");
1567 opt_default("bufsize", "327680"); // 40*1024*8;
1569 opt_default("b:a", "224000");
1570 parse_option(o, "ar", "44100", options);
1571 parse_option(o, "ac", "2", options);
1573 opt_default("packetsize", "2324");
1574 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1576 /* We have to offset the PTS, so that it is consistent with the SCR.
1577 SCR starts at 36000, but the first two packs contain only padding
1578 and the first pack from the other stream, respectively, may also have
1579 been written before.
1580 So the real data starts at SCR 36000+3*1200. */
1581 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1582 } else if (!strcmp(arg, "svcd")) {
1584 opt_video_codec(o, "c:v", "mpeg2video");
1585 opt_audio_codec(o, "c:a", "mp2");
1586 parse_option(o, "f", "svcd", options);
1588 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1589 parse_option(o, "r", frame_rates[norm], options);
1590 opt_default("g", norm == PAL ? "15" : "18");
1592 opt_default("b", "2040000");
1593 opt_default("maxrate", "2516000");
1594 opt_default("minrate", "0"); // 1145000;
1595 opt_default("bufsize", "1835008"); // 224*1024*8;
1596 opt_default("flags", "+scan_offset");
1599 opt_default("b:a", "224000");
1600 parse_option(o, "ar", "44100", options);
1602 opt_default("packetsize", "2324");
1604 } else if (!strcmp(arg, "dvd")) {
1606 opt_video_codec(o, "c:v", "mpeg2video");
1607 opt_audio_codec(o, "c:a", "ac3");
1608 parse_option(o, "f", "dvd", options);
1610 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1611 parse_option(o, "r", frame_rates[norm], options);
1612 opt_default("g", norm == PAL ? "15" : "18");
1614 opt_default("b", "6000000");
1615 opt_default("maxrate", "9000000");
1616 opt_default("minrate", "0"); // 1500000;
1617 opt_default("bufsize", "1835008"); // 224*1024*8;
1619 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1620 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1622 opt_default("b:a", "448000");
1623 parse_option(o, "ar", "48000", options);
1625 } else if (!strncmp(arg, "dv", 2)) {
1627 parse_option(o, "f", "dv", options);
1629 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1630 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1631 norm == PAL ? "yuv420p" : "yuv411p", options);
1632 parse_option(o, "r", frame_rates[norm], options);
1634 parse_option(o, "ar", "48000", options);
1635 parse_option(o, "ac", "2", options);
1638 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1639 return AVERROR(EINVAL);
1644 static int opt_vstats_file(const char *opt, const char *arg)
1646 av_free (vstats_filename);
1647 vstats_filename = av_strdup (arg);
1651 static int opt_vstats(const char *opt, const char *arg)
1654 time_t today2 = time(NULL);
1655 struct tm *today = localtime(&today2);
1657 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1659 return opt_vstats_file(opt, filename);
1662 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1664 OptionsContext *o = optctx;
1665 return parse_option(o, "frames:v", arg, options);
1668 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1670 OptionsContext *o = optctx;
1671 return parse_option(o, "frames:a", arg, options);
1674 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1676 OptionsContext *o = optctx;
1677 return parse_option(o, "frames:d", arg, options);
1680 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1682 OptionsContext *o = optctx;
1683 return parse_option(o, "tag:v", arg, options);
1686 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1688 OptionsContext *o = optctx;
1689 return parse_option(o, "tag:a", arg, options);
1692 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1694 OptionsContext *o = optctx;
1695 return parse_option(o, "tag:s", arg, options);
1698 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1700 OptionsContext *o = optctx;
1701 return parse_option(o, "filter:v", arg, options);
1704 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1706 OptionsContext *o = optctx;
1707 return parse_option(o, "filter:a", arg, options);
1710 static int opt_vsync(const char *opt, const char *arg)
1712 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1713 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1714 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1716 if (video_sync_method == VSYNC_AUTO)
1717 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1721 static int opt_deinterlace(const char *opt, const char *arg)
1723 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1728 int opt_cpuflags(const char *opt, const char *arg)
1730 int flags = av_parse_cpu_flags(arg);
1735 av_set_cpu_flags_mask(flags);
1739 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1741 OptionsContext *o = optctx;
1742 char layout_str[32];
1745 int ret, channels, ac_str_size;
1748 layout = av_get_channel_layout(arg);
1750 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1751 return AVERROR(EINVAL);
1753 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1754 ret = opt_default(opt, layout_str);
1758 /* set 'ac' option based on channel layout */
1759 channels = av_get_channel_layout_nb_channels(layout);
1760 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1761 stream_str = strchr(opt, ':');
1762 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1763 ac_str = av_mallocz(ac_str_size);
1765 return AVERROR(ENOMEM);
1766 av_strlcpy(ac_str, "ac", 3);
1768 av_strlcat(ac_str, stream_str, ac_str_size);
1769 ret = parse_option(o, ac_str, layout_str, options);
1775 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1777 OptionsContext *o = optctx;
1778 return parse_option(o, "q:a", arg, options);
1781 static int opt_filter_complex(const char *opt, const char *arg)
1783 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1784 &nb_filtergraphs, nb_filtergraphs + 1);
1785 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1786 return AVERROR(ENOMEM);
1787 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1788 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1792 void show_help_default(const char *opt, const char *arg)
1794 int show_advanced = 0, show_avoptions = 0;
1797 if (!strcmp(opt, "long"))
1799 else if (!strcmp(opt, "full"))
1800 show_advanced = show_avoptions = 1;
1802 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1807 printf("Getting help:\n"
1808 " -h -- print basic options\n"
1809 " -h long -- print more options\n"
1810 " -h full -- print all options (including all format and codec specific options, very long)\n"
1811 " See man %s for detailed description of the options.\n"
1812 "\n", program_name);
1814 show_help_options(options, "Print help / information / capabilities:",
1816 show_help_options(options, "Main options:",
1817 0, OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1820 show_help_options(options, "Advanced options:",
1821 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE);
1823 show_help_options(options, "Video options:",
1824 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO);
1826 show_help_options(options, "Advanced Video options:",
1827 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO);
1829 show_help_options(options, "Audio options:",
1830 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO);
1832 show_help_options(options, "Advanced Audio options:",
1833 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO);
1834 show_help_options(options, "Subtitle options:",
1838 if (show_avoptions) {
1839 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1840 show_help_children(avcodec_get_class(), flags);
1841 show_help_children(avformat_get_class(), flags);
1842 show_help_children(sws_get_class(), flags);
1846 void show_usage(void)
1848 printf("Hyper fast Audio and Video encoder\n");
1849 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1854 #define OFFSET(x) offsetof(OptionsContext, x)
1855 const OptionDef options[] = {
1857 #include "cmdutils_common_opts.h"
1858 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1859 "force format", "fmt" },
1860 { "i", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_input_file },
1861 "input file name", "filename" },
1862 { "y", OPT_BOOL, { &file_overwrite },
1863 "overwrite output files" },
1864 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1865 "codec name", "codec" },
1866 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1867 "codec name", "codec" },
1868 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1869 "preset name", "preset" },
1870 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_map },
1871 "set input stream mapping",
1872 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1873 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1874 "set metadata information of outfile from infile",
1875 "outfile[,metadata]:infile[,metadata]" },
1876 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1877 "set chapters mapping", "input_file_index" },
1878 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1879 "record or transcode \"duration\" seconds of audio/video",
1881 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1882 "set the limit file size in bytes", "limit_size" },
1883 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1884 "set the start time offset", "time_off" },
1885 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(input_ts_offset) },
1886 "set the input ts offset", "time_off" },
1887 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, { .off = OFFSET(ts_scale) },
1888 "set the input ts scale", "scale" },
1889 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1890 "add metadata", "string=string" },
1891 { "dframes", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_data_frames },
1892 "set the number of data frames to record", "number" },
1893 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1894 "add timings for benchmarking" },
1895 { "timelimit", HAS_ARG, { .func_arg = opt_timelimit },
1896 "set max runtime in seconds", "limit" },
1897 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1898 "dump each input packet" },
1899 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1900 "when dumping packets, also dump the payload" },
1901 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1902 "read input at native frame rate", "" },
1903 { "target", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_target },
1904 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1905 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1906 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1907 "video sync method", "" },
1908 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1909 "audio sync method", "" },
1910 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1911 "audio drift threshold", "threshold" },
1912 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1913 "copy timestamps" },
1914 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1915 "copy input stream time base when stream copying" },
1916 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1917 "finish encoding within shortest input" },
1918 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1919 "timestamp discontinuity delta threshold", "threshold" },
1920 { "xerror", OPT_BOOL, { &exit_on_error },
1921 "exit on error", "error" },
1922 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1923 "copy initial non-keyframes" },
1924 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1925 "set the number of frames to record", "number" },
1926 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, { .off = OFFSET(codec_tags) },
1927 "force codec tag/fourcc", "fourcc/tag" },
1928 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1929 "use fixed quality scale (VBR)", "q" },
1930 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1931 "use fixed quality scale (VBR)", "q" },
1932 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1933 "set stream filterchain", "filter_list" },
1934 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1935 "create a complex filtergraph", "graph_description" },
1936 { "stats", OPT_BOOL, { &print_stats },
1937 "print progress report during encoding", },
1938 { "attach", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_attach },
1939 "add an attachment to the output file", "filename" },
1940 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(dump_attachment) },
1941 "extract an attachment into a file", "filename" },
1942 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1943 "set CPU flags mask", "mask" },
1946 { "vframes", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_frames },
1947 "set the number of video frames to record", "number" },
1948 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1949 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1950 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1951 "set frame size (WxH or abbreviation)", "size" },
1952 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1953 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1954 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1955 "set pixel format", "format" },
1956 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1958 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1959 "discard threshold", "n" },
1960 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1961 "rate control override for specific intervals", "override" },
1962 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_codec },
1963 "force video codec ('copy' to copy stream)", "codec" },
1964 { "same_quant", OPT_VIDEO | OPT_BOOL , { &same_quant },
1965 "use same quantizer as source (implies VBR)" },
1966 { "pass", OPT_VIDEO | HAS_ARG , { opt_pass },
1967 "select the pass number (1 or 2)", "n" },
1968 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING , { &pass_logfilename_prefix },
1969 "select two pass log file name prefix", "prefix" },
1970 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1971 "this option is deprecated, use the yadif filter instead" },
1972 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1973 "dump video coding statistics to file" },
1974 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1975 "dump video coding statistics to file", "file" },
1976 { "vf", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_filters },
1977 "video filters", "filter list" },
1978 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1979 "specify intra matrix coeffs", "matrix" },
1980 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1981 "specify inter matrix coeffs", "matrix" },
1982 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1983 "top=1/bottom=0/auto=-1 field first", "" },
1984 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1985 "intra_dc_precision", "precision" },
1986 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_video_tag },
1987 "force video tag/fourcc", "fourcc/tag" },
1988 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1989 "show QP histogram" },
1990 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
1991 "force the selected framerate, disable the best supported framerate selection" },
1992 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_streamid },
1993 "set the value of an outfile streamid", "streamIndex:value" },
1994 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
1995 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
1998 { "aframes", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_frames },
1999 "set the number of audio frames to record", "number" },
2000 { "aq", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_qscale },
2001 "set audio quality (codec-specific)", "quality", },
2002 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2003 "set audio sampling rate (in Hz)", "rate" },
2004 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2005 "set number of audio channels", "channels" },
2006 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2008 { "acodec", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_codec },
2009 "force audio codec ('copy' to copy stream)", "codec" },
2010 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_audio_tag },
2011 "force audio tag/fourcc", "fourcc/tag" },
2012 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2013 "change audio volume (256=normal)" , "volume" },
2014 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2015 "set sample format", "format" },
2016 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_channel_layout },
2017 "set channel layout", "layout" },
2018 { "af", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_filters },
2019 "audio filters", "filter list" },
2021 /* subtitle options */
2022 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2023 "disable subtitle" },
2024 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_subtitle_codec },
2025 "force subtitle codec ('copy' to copy stream)", "codec" },
2026 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_subtitle_tag }
2027 , "force subtitle tag/fourcc", "fourcc/tag" },
2030 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2033 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2034 "set the maximum demux-decode delay", "seconds" },
2035 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2036 "set the initial demux-decode delay", "seconds" },
2038 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(bitstream_filters) },
2039 "A comma-separated list of bitstream filters", "bitstream_filters" },
2041 /* data codec support */
2042 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, { .func2_arg = opt_data_codec },
2043 "force data codec ('copy' to copy stream)", "codec" },
2045 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2046 "generic catch all option", "" },