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;
72 int exit_on_error = 0;
77 static int file_overwrite = 0;
78 static int video_discard = 0;
79 static int intra_dc_precision = 8;
80 static int do_pass = 0;
81 static int using_stdin = 0;
82 static int input_sync;
84 void reset_options(OptionsContext *o)
86 const OptionDef *po = options;
89 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
91 void *dst = (uint8_t*)o + po->u.off;
93 if (po->flags & OPT_SPEC) {
94 SpecifierOpt **so = dst;
95 int i, *count = (int*)(so + 1);
96 for (i = 0; i < *count; i++) {
97 av_freep(&(*so)[i].specifier);
98 if (po->flags & OPT_STRING)
99 av_freep(&(*so)[i].u.str);
103 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
108 for (i = 0; i < o->nb_stream_maps; i++)
109 av_freep(&o->stream_maps[i].linklabel);
110 av_freep(&o->stream_maps);
111 av_freep(&o->meta_data_maps);
112 av_freep(&o->streamid_map);
114 memset(o, 0, sizeof(*o));
116 o->mux_max_delay = 0.7;
117 o->recording_time = INT64_MAX;
118 o->limit_filesize = UINT64_MAX;
119 o->chapters_input_file = INT_MAX;
126 static double parse_frame_aspect_ratio(const char *arg)
133 p = strchr(arg, ':');
135 x = strtol(arg, &end, 10);
137 y = strtol(end + 1, &end, 10);
139 ar = (double)x / (double)y;
141 ar = strtod(arg, NULL);
144 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
150 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
152 OptionsContext *o = optctx;
153 return parse_option(o, "codec:a", arg, options);
156 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
158 OptionsContext *o = optctx;
159 return parse_option(o, "codec:v", arg, options);
162 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
164 OptionsContext *o = optctx;
165 return parse_option(o, "codec:s", arg, options);
168 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
170 OptionsContext *o = optctx;
171 return parse_option(o, "codec:d", arg, options);
174 static int opt_map(void *optctx, const char *opt, const char *arg)
176 OptionsContext *o = optctx;
178 int i, negative = 0, file_idx;
179 int sync_file_idx = -1, sync_stream_idx;
187 map = av_strdup(arg);
189 /* parse sync stream first, just pick first matching stream */
190 if (sync = strchr(map, ',')) {
192 sync_file_idx = strtol(sync + 1, &sync, 0);
193 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
194 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
199 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
200 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
201 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
205 if (i == input_files[sync_file_idx]->nb_streams) {
206 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
207 "match any streams.\n", arg);
214 /* this mapping refers to lavfi output */
215 const char *c = map + 1;
216 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
217 &o->nb_stream_maps, o->nb_stream_maps + 1);
218 m = &o->stream_maps[o->nb_stream_maps - 1];
219 m->linklabel = av_get_token(&c, "]");
221 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
225 file_idx = strtol(map, &p, 0);
226 if (file_idx >= nb_input_files || file_idx < 0) {
227 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
231 /* disable some already defined maps */
232 for (i = 0; i < o->nb_stream_maps; i++) {
233 m = &o->stream_maps[i];
234 if (file_idx == m->file_index &&
235 check_stream_specifier(input_files[m->file_index]->ctx,
236 input_files[m->file_index]->ctx->streams[m->stream_index],
237 *p == ':' ? p + 1 : p) > 0)
241 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
242 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
243 *p == ':' ? p + 1 : p) <= 0)
245 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
246 &o->nb_stream_maps, o->nb_stream_maps + 1);
247 m = &o->stream_maps[o->nb_stream_maps - 1];
249 m->file_index = file_idx;
252 if (sync_file_idx >= 0) {
253 m->sync_file_index = sync_file_idx;
254 m->sync_stream_index = sync_stream_idx;
256 m->sync_file_index = file_idx;
257 m->sync_stream_index = i;
263 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
271 static int opt_attach(void *optctx, const char *opt, const char *arg)
273 OptionsContext *o = optctx;
274 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
275 &o->nb_attachments, o->nb_attachments + 1);
276 o->attachments[o->nb_attachments - 1] = arg;
281 * Parse a metadata specifier in arg.
282 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
283 * @param index for type c/p, chapter/program index is written here
284 * @param stream_spec for type s, the stream specifier is written here
286 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
294 if (*(++arg) && *arg != ':') {
295 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
298 *stream_spec = *arg == ':' ? arg + 1 : "";
303 *index = strtol(++arg, NULL, 0);
306 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
313 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
315 AVDictionary **meta_in = NULL;
316 AVDictionary **meta_out;
318 char type_in, type_out;
319 const char *istream_spec = NULL, *ostream_spec = NULL;
320 int idx_in = 0, idx_out = 0;
322 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
323 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
325 if (type_in == 'g' || type_out == 'g')
326 o->metadata_global_manual = 1;
327 if (type_in == 's' || type_out == 's')
328 o->metadata_streams_manual = 1;
329 if (type_in == 'c' || type_out == 'c')
330 o->metadata_chapters_manual = 1;
332 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
333 if ((index) < 0 || (index) >= (nb_elems)) {\
334 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
339 #define SET_DICT(type, meta, context, index)\
342 meta = &context->metadata;\
345 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
346 meta = &context->chapters[index]->metadata;\
349 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
350 meta = &context->programs[index]->metadata;\
352 default: av_assert0(0);\
355 SET_DICT(type_in, meta_in, ic, idx_in);
356 SET_DICT(type_out, meta_out, oc, idx_out);
358 /* for input streams choose first matching stream */
359 if (type_in == 's') {
360 for (i = 0; i < ic->nb_streams; i++) {
361 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
362 meta_in = &ic->streams[i]->metadata;
368 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
373 if (type_out == 's') {
374 for (i = 0; i < oc->nb_streams; i++) {
375 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
376 meta_out = &oc->streams[i]->metadata;
377 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
382 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
389 const AVCodecDescriptor *desc;
390 const char *codec_string = encoder ? "encoder" : "decoder";
394 avcodec_find_encoder_by_name(name) :
395 avcodec_find_decoder_by_name(name);
397 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
398 codec = encoder ? avcodec_find_encoder(desc->id) :
399 avcodec_find_decoder(desc->id);
401 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
402 codec_string, codec->name, desc->name);
406 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
409 if (codec->type != type) {
410 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
416 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
418 char *codec_name = NULL;
420 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
422 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
423 st->codec->codec_id = codec->id;
426 return avcodec_find_decoder(st->codec->codec_id);
430 * Add all the streams from the given input file to the global
431 * list of input streams.
433 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
437 for (i = 0; i < ic->nb_streams; i++) {
438 AVStream *st = ic->streams[i];
439 AVCodecContext *dec = st->codec;
440 InputStream *ist = av_mallocz(sizeof(*ist));
441 char *framerate = NULL;
446 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
447 input_streams[nb_input_streams - 1] = ist;
450 ist->file_index = nb_input_files;
452 st->discard = AVDISCARD_ALL;
453 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
456 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
458 ist->dec = choose_decoder(o, ic, st);
460 switch (dec->codec_type) {
461 case AVMEDIA_TYPE_VIDEO:
462 ist->resample_height = dec->height;
463 ist->resample_width = dec->width;
464 ist->resample_pix_fmt = dec->pix_fmt;
466 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
467 if (framerate && av_parse_video_rate(&ist->framerate,
469 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
475 case AVMEDIA_TYPE_AUDIO:
476 guess_input_channel_layout(ist);
478 ist->resample_sample_fmt = dec->sample_fmt;
479 ist->resample_sample_rate = dec->sample_rate;
480 ist->resample_channels = dec->channels;
481 ist->resample_channel_layout = dec->channel_layout;
484 case AVMEDIA_TYPE_DATA:
485 case AVMEDIA_TYPE_SUBTITLE:
486 case AVMEDIA_TYPE_ATTACHMENT:
487 case AVMEDIA_TYPE_UNKNOWN:
495 static void assert_file_overwrite(const char *filename)
497 if (!file_overwrite &&
498 (strchr(filename, ':') == NULL || filename[1] == ':' ||
499 av_strstart(filename, "file:", NULL))) {
500 if (avio_check(filename, 0) == 0) {
502 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
505 fprintf(stderr, "Not overwriting - exiting\n");
510 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
517 static void dump_attachment(AVStream *st, const char *filename)
520 AVIOContext *out = NULL;
521 AVDictionaryEntry *e;
523 if (!st->codec->extradata_size) {
524 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
525 nb_input_files - 1, st->index);
528 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
531 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
532 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
536 assert_file_overwrite(filename);
538 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
539 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
544 avio_write(out, st->codec->extradata, st->codec->extradata_size);
549 static int opt_input_file(void *optctx, const char *opt, const char *filename)
551 OptionsContext *o = optctx;
553 AVInputFormat *file_iformat = NULL;
558 int orig_nb_streams; // number of streams before avformat_find_stream_info
561 if (!(file_iformat = av_find_input_format(o->format))) {
562 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
567 if (!strcmp(filename, "-"))
570 using_stdin |= !strncmp(filename, "pipe:", 5) ||
571 !strcmp(filename, "/dev/stdin");
573 /* get default parameters from command line */
574 ic = avformat_alloc_context();
576 print_error(filename, AVERROR(ENOMEM));
579 if (o->nb_audio_sample_rate) {
580 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
581 av_dict_set(&format_opts, "sample_rate", buf, 0);
583 if (o->nb_audio_channels) {
584 /* because we set audio_channels based on both the "ac" and
585 * "channel_layout" options, we need to check that the specified
586 * demuxer actually has the "channels" option before setting it */
587 if (file_iformat && file_iformat->priv_class &&
588 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
589 AV_OPT_SEARCH_FAKE_OBJ)) {
590 snprintf(buf, sizeof(buf), "%d",
591 o->audio_channels[o->nb_audio_channels - 1].u.i);
592 av_dict_set(&format_opts, "channels", buf, 0);
595 if (o->nb_frame_rates) {
596 /* set the format-level framerate option;
597 * this is important for video grabbers, e.g. x11 */
598 if (file_iformat && file_iformat->priv_class &&
599 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
600 AV_OPT_SEARCH_FAKE_OBJ)) {
601 av_dict_set(&format_opts, "framerate",
602 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
605 if (o->nb_frame_sizes) {
606 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
608 if (o->nb_frame_pix_fmts)
609 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
611 ic->flags |= AVFMT_FLAG_NONBLOCK;
612 ic->interrupt_callback = int_cb;
614 /* open the input file with generic libav function */
615 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
617 print_error(filename, err);
620 assert_avoptions(format_opts);
622 /* apply forced codec ids */
623 for (i = 0; i < ic->nb_streams; i++)
624 choose_decoder(o, ic, ic->streams[i]);
626 /* Set AVCodecContext options for avformat_find_stream_info */
627 opts = setup_find_stream_info_opts(ic, codec_opts);
628 orig_nb_streams = ic->nb_streams;
630 /* If not enough info to get the stream parameters, we decode the
631 first frames to get it. (used in mpeg case for example) */
632 ret = avformat_find_stream_info(ic, opts);
634 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
635 avformat_close_input(&ic);
639 timestamp = o->start_time;
640 /* add the stream start time */
641 if (ic->start_time != AV_NOPTS_VALUE)
642 timestamp += ic->start_time;
644 /* if seeking requested, we execute it */
645 if (o->start_time != 0) {
646 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
648 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
649 filename, (double)timestamp / AV_TIME_BASE);
653 /* update the current parameters so that they match the one of the input stream */
654 add_input_streams(o, ic);
656 /* dump the file content */
657 av_dump_format(ic, nb_input_files, filename, 0);
659 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
660 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
663 input_files[nb_input_files - 1]->ctx = ic;
664 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
665 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
666 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
667 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
669 for (i = 0; i < o->nb_dump_attachment; i++) {
672 for (j = 0; j < ic->nb_streams; j++) {
673 AVStream *st = ic->streams[j];
675 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
676 dump_attachment(st, o->dump_attachment[i].u.str);
680 for (i = 0; i < orig_nb_streams; i++)
681 av_dict_free(&opts[i]);
688 static uint8_t *get_line(AVIOContext *s)
694 if (avio_open_dyn_buf(&line) < 0) {
695 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
699 while ((c = avio_r8(s)) && c != '\n')
702 avio_close_dyn_buf(line, &buf);
707 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
711 const char *base[3] = { getenv("AVCONV_DATADIR"),
716 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
720 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
721 i != 1 ? "" : "/.avconv", codec_name, preset_name);
722 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
725 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
726 i != 1 ? "" : "/.avconv", preset_name);
727 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
733 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
735 char *codec_name = NULL;
737 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
739 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
740 NULL, ost->st->codec->codec_type);
741 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
742 } else if (!strcmp(codec_name, "copy"))
743 ost->stream_copy = 1;
745 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
746 ost->st->codec->codec_id = ost->enc->id;
750 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
753 AVStream *st = avformat_new_stream(oc, NULL);
754 int idx = oc->nb_streams - 1, ret = 0;
755 char *bsf = NULL, *next, *codec_tag = NULL;
756 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
758 char *buf = NULL, *arg = NULL, *preset = NULL;
759 AVIOContext *s = NULL;
762 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
766 if (oc->nb_streams - 1 < o->nb_streamid_map)
767 st->id = o->streamid_map[oc->nb_streams - 1];
769 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
770 nb_output_streams + 1);
771 if (!(ost = av_mallocz(sizeof(*ost))))
773 output_streams[nb_output_streams - 1] = ost;
775 ost->file_index = nb_output_files;
778 st->codec->codec_type = type;
779 choose_encoder(o, oc, ost);
781 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
784 avcodec_get_context_defaults3(st->codec, ost->enc);
785 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
787 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
788 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
791 if (!buf[0] || buf[0] == '#') {
795 if (!(arg = strchr(buf, '='))) {
796 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
800 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
802 } while (!s->eof_reached);
806 av_log(NULL, AV_LOG_FATAL,
807 "Preset %s specified for stream %d:%d, but could not be opened.\n",
808 preset, ost->file_index, ost->index);
812 ost->max_frames = INT64_MAX;
813 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
815 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
817 if (next = strchr(bsf, ','))
819 if (!(bsfc = av_bitstream_filter_init(bsf))) {
820 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
824 bsfc_prev->next = bsfc;
826 ost->bitstream_filters = bsfc;
832 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
834 uint32_t tag = strtol(codec_tag, &next, 0);
836 tag = AV_RL32(codec_tag);
837 st->codec->codec_tag = tag;
840 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
841 if (qscale >= 0 || same_quant) {
842 st->codec->flags |= CODEC_FLAG_QSCALE;
843 st->codec->global_quality = FF_QP2LAMBDA * qscale;
846 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
847 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
849 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
851 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
866 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
877 AVCodecContext *video_enc;
879 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
881 video_enc = st->codec;
883 if (!ost->stream_copy) {
884 const char *p = NULL;
885 char *frame_rate = NULL, *frame_size = NULL;
886 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
887 char *intra_matrix = NULL, *inter_matrix = NULL;
888 const char *filters = "null";
891 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
892 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
897 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
898 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
899 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
903 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
904 if (frame_aspect_ratio)
905 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
907 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
908 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
909 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
912 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
914 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
916 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
917 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
920 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
922 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
924 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
925 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
928 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
931 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
932 for (i = 0; p; i++) {
934 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
936 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
939 video_enc->rc_override =
940 av_realloc(video_enc->rc_override,
941 sizeof(RcOverride) * (i + 1));
942 video_enc->rc_override[i].start_frame = start;
943 video_enc->rc_override[i].end_frame = end;
945 video_enc->rc_override[i].qscale = q;
946 video_enc->rc_override[i].quality_factor = 1.0;
949 video_enc->rc_override[i].qscale = 0;
950 video_enc->rc_override[i].quality_factor = -q/100.0;
955 video_enc->rc_override_count = i;
956 if (!video_enc->rc_initial_buffer_occupancy)
957 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
958 video_enc->intra_dc_precision = intra_dc_precision - 8;
963 video_enc->flags |= CODEC_FLAG_PASS1;
965 video_enc->flags |= CODEC_FLAG_PASS2;
969 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
970 if (ost->forced_keyframes)
971 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
973 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
975 ost->top_field_first = -1;
976 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
978 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
979 ost->avfilter = av_strdup(filters);
981 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
987 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
991 AVCodecContext *audio_enc;
993 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
996 audio_enc = st->codec;
997 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
999 if (!ost->stream_copy) {
1000 char *sample_fmt = NULL;
1001 const char *filters = "anull";
1003 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1005 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1007 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1008 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1012 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1014 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1015 ost->avfilter = av_strdup(filters);
1021 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1025 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1026 if (!ost->stream_copy) {
1027 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1034 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1036 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1037 ost->stream_copy = 1;
1041 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1045 AVCodecContext *subtitle_enc;
1047 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1049 subtitle_enc = st->codec;
1051 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1056 /* arg format is "output-stream-index:streamid-value". */
1057 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1059 OptionsContext *o = optctx;
1064 av_strlcpy(idx_str, arg, sizeof(idx_str));
1065 p = strchr(idx_str, ':');
1067 av_log(NULL, AV_LOG_FATAL,
1068 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1073 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1074 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1075 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1079 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1081 AVFormatContext *is = ifile->ctx;
1082 AVFormatContext *os = ofile->ctx;
1085 for (i = 0; i < is->nb_chapters; i++) {
1086 AVChapter *in_ch = is->chapters[i], *out_ch;
1087 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1088 AV_TIME_BASE_Q, in_ch->time_base);
1089 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1090 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1093 if (in_ch->end < ts_off)
1095 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1098 out_ch = av_mallocz(sizeof(AVChapter));
1100 return AVERROR(ENOMEM);
1102 out_ch->id = in_ch->id;
1103 out_ch->time_base = in_ch->time_base;
1104 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1105 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1108 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1111 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
1113 return AVERROR(ENOMEM);
1114 os->chapters[os->nb_chapters - 1] = out_ch;
1119 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1120 AVFormatContext *oc)
1124 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1125 ofilter->out_tmp->pad_idx)) {
1126 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1127 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1129 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1134 ost->source_index = -1;
1135 ost->filter = ofilter;
1139 if (ost->stream_copy) {
1140 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1141 "which is fed from a complex filtergraph. Filtering and streamcopy "
1142 "cannot be used together.\n", ost->file_index, ost->index);
1146 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1147 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1150 avfilter_inout_free(&ofilter->out_tmp);
1153 static int configure_complex_filters(void)
1157 for (i = 0; i < nb_filtergraphs; i++)
1158 if (!filtergraphs[i]->graph &&
1159 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1164 void opt_output_file(void *optctx, const char *filename)
1166 OptionsContext *o = optctx;
1167 AVFormatContext *oc;
1169 AVOutputFormat *file_oformat;
1173 if (configure_complex_filters() < 0) {
1174 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1178 if (!strcmp(filename, "-"))
1181 oc = avformat_alloc_context();
1183 print_error(filename, AVERROR(ENOMEM));
1188 file_oformat = av_guess_format(o->format, NULL, NULL);
1189 if (!file_oformat) {
1190 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1194 file_oformat = av_guess_format(NULL, filename, NULL);
1195 if (!file_oformat) {
1196 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1202 oc->oformat = file_oformat;
1203 oc->interrupt_callback = int_cb;
1204 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1206 /* create streams for all unlabeled output pads */
1207 for (i = 0; i < nb_filtergraphs; i++) {
1208 FilterGraph *fg = filtergraphs[i];
1209 for (j = 0; j < fg->nb_outputs; j++) {
1210 OutputFilter *ofilter = fg->outputs[j];
1212 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1215 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1216 ofilter->out_tmp->pad_idx)) {
1217 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1218 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1219 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1221 init_output_filter(ofilter, o, oc);
1225 if (!o->nb_stream_maps) {
1226 /* pick the "best" stream of each type */
1227 #define NEW_STREAM(type, index)\
1229 ost = new_ ## type ## _stream(o, oc);\
1230 ost->source_index = index;\
1231 ost->sync_ist = input_streams[index];\
1232 input_streams[index]->discard = 0;\
1233 input_streams[index]->st->discard = AVDISCARD_NONE;\
1236 /* video: highest resolution */
1237 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1238 int area = 0, idx = -1;
1239 for (i = 0; i < nb_input_streams; i++) {
1240 ist = input_streams[i];
1241 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1242 ist->st->codec->width * ist->st->codec->height > area) {
1243 area = ist->st->codec->width * ist->st->codec->height;
1247 NEW_STREAM(video, idx);
1250 /* audio: most channels */
1251 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1252 int channels = 0, idx = -1;
1253 for (i = 0; i < nb_input_streams; i++) {
1254 ist = input_streams[i];
1255 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1256 ist->st->codec->channels > channels) {
1257 channels = ist->st->codec->channels;
1261 NEW_STREAM(audio, idx);
1264 /* subtitles: pick first */
1265 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1266 for (i = 0; i < nb_input_streams; i++)
1267 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1268 NEW_STREAM(subtitle, i);
1272 /* do something with data? */
1274 for (i = 0; i < o->nb_stream_maps; i++) {
1275 StreamMap *map = &o->stream_maps[i];
1280 if (map->linklabel) {
1282 OutputFilter *ofilter = NULL;
1285 for (j = 0; j < nb_filtergraphs; j++) {
1286 fg = filtergraphs[j];
1287 for (k = 0; k < fg->nb_outputs; k++) {
1288 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1289 if (out && !strcmp(out->name, map->linklabel)) {
1290 ofilter = fg->outputs[k];
1297 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1298 "in any defined filter graph.\n", map->linklabel);
1301 init_output_filter(ofilter, o, oc);
1303 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1304 switch (ist->st->codec->codec_type) {
1305 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1306 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1307 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1308 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1309 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1311 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1312 map->file_index, map->stream_index);
1316 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1317 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1318 map->sync_stream_index];
1320 ist->st->discard = AVDISCARD_NONE;
1325 /* handle attached files */
1326 for (i = 0; i < o->nb_attachments; i++) {
1328 uint8_t *attachment;
1332 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1333 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1337 if ((len = avio_size(pb)) <= 0) {
1338 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1342 if (!(attachment = av_malloc(len))) {
1343 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1347 avio_read(pb, attachment, len);
1349 ost = new_attachment_stream(o, oc);
1350 ost->stream_copy = 0;
1351 ost->source_index = -1;
1352 ost->attachment_filename = o->attachments[i];
1353 ost->st->codec->extradata = attachment;
1354 ost->st->codec->extradata_size = len;
1356 p = strrchr(o->attachments[i], '/');
1357 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1361 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1362 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1365 output_files[nb_output_files - 1]->ctx = oc;
1366 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1367 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1368 if (o->recording_time != INT64_MAX)
1369 oc->duration = o->recording_time;
1370 output_files[nb_output_files - 1]->start_time = o->start_time;
1371 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1372 output_files[nb_output_files - 1]->shortest = o->shortest;
1373 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1375 /* check filename in case of an image number is expected */
1376 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1377 if (!av_filename_number_test(oc->filename)) {
1378 print_error(oc->filename, AVERROR(EINVAL));
1383 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1384 /* test if it already exists to avoid losing precious files */
1385 assert_file_overwrite(filename);
1388 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1389 &oc->interrupt_callback,
1390 &output_files[nb_output_files - 1]->opts)) < 0) {
1391 print_error(filename, err);
1396 if (o->mux_preload) {
1398 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1399 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1401 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1402 oc->flags |= AVFMT_FLAG_NONBLOCK;
1405 for (i = 0; i < o->nb_metadata_map; i++) {
1407 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1409 if (in_file_index < 0)
1411 if (in_file_index >= nb_input_files) {
1412 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1415 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
1419 if (o->chapters_input_file >= nb_input_files) {
1420 if (o->chapters_input_file == INT_MAX) {
1421 /* copy chapters from the first input file that has them*/
1422 o->chapters_input_file = -1;
1423 for (i = 0; i < nb_input_files; i++)
1424 if (input_files[i]->ctx->nb_chapters) {
1425 o->chapters_input_file = i;
1429 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1430 o->chapters_input_file);
1434 if (o->chapters_input_file >= 0)
1435 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1436 !o->metadata_chapters_manual);
1438 /* copy global metadata by default */
1439 if (!o->metadata_global_manual && nb_input_files)
1440 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1441 AV_DICT_DONT_OVERWRITE);
1442 if (!o->metadata_streams_manual)
1443 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1445 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1447 ist = input_streams[output_streams[i]->source_index];
1448 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1451 /* process manually set metadata */
1452 for (i = 0; i < o->nb_metadata; i++) {
1455 const char *stream_spec;
1456 int index = 0, j, ret;
1458 val = strchr(o->metadata[i].u.str, '=');
1460 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1461 o->metadata[i].u.str);
1466 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1468 for (j = 0; j < oc->nb_streams; j++) {
1469 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1470 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1481 if (index < 0 || index >= oc->nb_chapters) {
1482 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1485 m = &oc->chapters[index]->metadata;
1488 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1491 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1498 /* same option as mencoder */
1499 static int opt_pass(const char *opt, const char *arg)
1501 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
1506 static int opt_target(void *optctx, const char *opt, const char *arg)
1508 OptionsContext *o = optctx;
1509 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1510 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1512 if (!strncmp(arg, "pal-", 4)) {
1515 } else if (!strncmp(arg, "ntsc-", 5)) {
1518 } else if (!strncmp(arg, "film-", 5)) {
1522 /* Try to determine PAL/NTSC by peeking in the input files */
1523 if (nb_input_files) {
1525 for (j = 0; j < nb_input_files; j++) {
1526 for (i = 0; i < input_files[j]->nb_streams; i++) {
1527 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1528 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1530 fr = c->time_base.den * 1000 / c->time_base.num;
1534 } else if ((fr == 29970) || (fr == 23976)) {
1539 if (norm != UNKNOWN)
1543 if (norm != UNKNOWN)
1544 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1547 if (norm == UNKNOWN) {
1548 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1549 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1550 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1554 if (!strcmp(arg, "vcd")) {
1555 opt_video_codec(o, "c:v", "mpeg1video");
1556 opt_audio_codec(o, "c:a", "mp2");
1557 parse_option(o, "f", "vcd", options);
1559 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1560 parse_option(o, "r", frame_rates[norm], options);
1561 opt_default("g", norm == PAL ? "15" : "18");
1563 opt_default("b", "1150000");
1564 opt_default("maxrate", "1150000");
1565 opt_default("minrate", "1150000");
1566 opt_default("bufsize", "327680"); // 40*1024*8;
1568 opt_default("b:a", "224000");
1569 parse_option(o, "ar", "44100", options);
1570 parse_option(o, "ac", "2", options);
1572 opt_default("packetsize", "2324");
1573 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1575 /* We have to offset the PTS, so that it is consistent with the SCR.
1576 SCR starts at 36000, but the first two packs contain only padding
1577 and the first pack from the other stream, respectively, may also have
1578 been written before.
1579 So the real data starts at SCR 36000+3*1200. */
1580 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1581 } else if (!strcmp(arg, "svcd")) {
1583 opt_video_codec(o, "c:v", "mpeg2video");
1584 opt_audio_codec(o, "c:a", "mp2");
1585 parse_option(o, "f", "svcd", options);
1587 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1588 parse_option(o, "r", frame_rates[norm], options);
1589 opt_default("g", norm == PAL ? "15" : "18");
1591 opt_default("b", "2040000");
1592 opt_default("maxrate", "2516000");
1593 opt_default("minrate", "0"); // 1145000;
1594 opt_default("bufsize", "1835008"); // 224*1024*8;
1595 opt_default("flags", "+scan_offset");
1598 opt_default("b:a", "224000");
1599 parse_option(o, "ar", "44100", options);
1601 opt_default("packetsize", "2324");
1603 } else if (!strcmp(arg, "dvd")) {
1605 opt_video_codec(o, "c:v", "mpeg2video");
1606 opt_audio_codec(o, "c:a", "ac3");
1607 parse_option(o, "f", "dvd", options);
1609 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1610 parse_option(o, "r", frame_rates[norm], options);
1611 opt_default("g", norm == PAL ? "15" : "18");
1613 opt_default("b", "6000000");
1614 opt_default("maxrate", "9000000");
1615 opt_default("minrate", "0"); // 1500000;
1616 opt_default("bufsize", "1835008"); // 224*1024*8;
1618 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1619 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1621 opt_default("b:a", "448000");
1622 parse_option(o, "ar", "48000", options);
1624 } else if (!strncmp(arg, "dv", 2)) {
1626 parse_option(o, "f", "dv", options);
1628 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1629 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1630 norm == PAL ? "yuv420p" : "yuv411p", options);
1631 parse_option(o, "r", frame_rates[norm], options);
1633 parse_option(o, "ar", "48000", options);
1634 parse_option(o, "ac", "2", options);
1637 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1638 return AVERROR(EINVAL);
1643 static int opt_vstats_file(const char *opt, const char *arg)
1645 av_free (vstats_filename);
1646 vstats_filename = av_strdup (arg);
1650 static int opt_vstats(const char *opt, const char *arg)
1653 time_t today2 = time(NULL);
1654 struct tm *today = localtime(&today2);
1656 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1658 return opt_vstats_file(opt, filename);
1661 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1663 OptionsContext *o = optctx;
1664 return parse_option(o, "frames:v", arg, options);
1667 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1669 OptionsContext *o = optctx;
1670 return parse_option(o, "frames:a", arg, options);
1673 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1675 OptionsContext *o = optctx;
1676 return parse_option(o, "frames:d", arg, options);
1679 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1681 OptionsContext *o = optctx;
1682 return parse_option(o, "tag:v", arg, options);
1685 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1687 OptionsContext *o = optctx;
1688 return parse_option(o, "tag:a", arg, options);
1691 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1693 OptionsContext *o = optctx;
1694 return parse_option(o, "tag:s", arg, options);
1697 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1699 OptionsContext *o = optctx;
1700 return parse_option(o, "filter:v", arg, options);
1703 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1705 OptionsContext *o = optctx;
1706 return parse_option(o, "filter:a", arg, options);
1709 static int opt_vsync(const char *opt, const char *arg)
1711 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1712 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1713 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1715 if (video_sync_method == VSYNC_AUTO)
1716 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1720 static int opt_deinterlace(const char *opt, const char *arg)
1722 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1727 int opt_cpuflags(const char *opt, const char *arg)
1729 int flags = av_parse_cpu_flags(arg);
1734 av_set_cpu_flags_mask(flags);
1738 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1740 OptionsContext *o = optctx;
1741 char layout_str[32];
1744 int ret, channels, ac_str_size;
1747 layout = av_get_channel_layout(arg);
1749 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1750 return AVERROR(EINVAL);
1752 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1753 ret = opt_default(opt, layout_str);
1757 /* set 'ac' option based on channel layout */
1758 channels = av_get_channel_layout_nb_channels(layout);
1759 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1760 stream_str = strchr(opt, ':');
1761 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1762 ac_str = av_mallocz(ac_str_size);
1764 return AVERROR(ENOMEM);
1765 av_strlcpy(ac_str, "ac", 3);
1767 av_strlcat(ac_str, stream_str, ac_str_size);
1768 ret = parse_option(o, ac_str, layout_str, options);
1774 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1776 OptionsContext *o = optctx;
1777 return parse_option(o, "q:a", arg, options);
1780 static int opt_filter_complex(const char *opt, const char *arg)
1782 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1783 &nb_filtergraphs, nb_filtergraphs + 1);
1784 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1785 return AVERROR(ENOMEM);
1786 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1787 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1791 void show_help_default(const char *opt, const char *arg)
1793 /* per-file options have at least one of those set */
1794 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_FUNC2;
1795 int show_advanced = 0, show_avoptions = 0;
1798 if (!strcmp(opt, "long"))
1800 else if (!strcmp(opt, "full"))
1801 show_advanced = show_avoptions = 1;
1803 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1808 printf("Getting help:\n"
1809 " -h -- print basic options\n"
1810 " -h long -- print more options\n"
1811 " -h full -- print all options (including all format and codec specific options, very long)\n"
1812 " See man %s for detailed description of the options.\n"
1813 "\n", program_name);
1815 show_help_options(options, "Print help / information / capabilities:",
1818 show_help_options(options, "Global options (affect whole program "
1819 "instead of just one file:",
1820 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1822 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1823 per_file | OPT_EXIT, 0);
1825 show_help_options(options, "Per-file main options:", 0,
1826 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1827 OPT_EXIT, per_file);
1829 show_help_options(options, "Advanced per-file options:",
1830 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1832 show_help_options(options, "Video options:",
1833 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1835 show_help_options(options, "Advanced Video options:",
1836 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1838 show_help_options(options, "Audio options:",
1839 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1841 show_help_options(options, "Advanced Audio options:",
1842 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1843 show_help_options(options, "Subtitle options:",
1844 OPT_SUBTITLE, 0, 0);
1847 if (show_avoptions) {
1848 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1849 show_help_children(avcodec_get_class(), flags);
1850 show_help_children(avformat_get_class(), flags);
1851 show_help_children(sws_get_class(), flags);
1855 void show_usage(void)
1857 printf("Hyper fast Audio and Video encoder\n");
1858 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1863 #define OFFSET(x) offsetof(OptionsContext, x)
1864 const OptionDef options[] = {
1866 #include "cmdutils_common_opts.h"
1867 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1868 "force format", "fmt" },
1869 { "i", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_input_file },
1870 "input file name", "filename" },
1871 { "y", OPT_BOOL, { &file_overwrite },
1872 "overwrite output files" },
1873 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1874 "codec name", "codec" },
1875 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1876 "codec name", "codec" },
1877 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1878 "preset name", "preset" },
1879 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_map },
1880 "set input stream mapping",
1881 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1882 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1883 "set metadata information of outfile from infile",
1884 "outfile[,metadata]:infile[,metadata]" },
1885 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1886 "set chapters mapping", "input_file_index" },
1887 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1888 "record or transcode \"duration\" seconds of audio/video",
1890 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1891 "set the limit file size in bytes", "limit_size" },
1892 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1893 "set the start time offset", "time_off" },
1894 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1895 "set the input ts offset", "time_off" },
1896 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1897 "set the input ts scale", "scale" },
1898 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1899 "add metadata", "string=string" },
1900 { "dframes", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_frames },
1901 "set the number of data frames to record", "number" },
1902 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1903 "add timings for benchmarking" },
1904 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1905 "set max runtime in seconds", "limit" },
1906 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1907 "dump each input packet" },
1908 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1909 "when dumping packets, also dump the payload" },
1910 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1911 "read input at native frame rate", "" },
1912 { "target", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_target },
1913 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1914 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1915 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1916 "video sync method", "" },
1917 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1918 "audio sync method", "" },
1919 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1920 "audio drift threshold", "threshold" },
1921 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1922 "copy timestamps" },
1923 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1924 "copy input stream time base when stream copying" },
1925 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1926 "finish encoding within shortest input" },
1927 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1928 "timestamp discontinuity delta threshold", "threshold" },
1929 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1930 "exit on error", "error" },
1931 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1932 "copy initial non-keyframes" },
1933 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1934 "set the number of frames to record", "number" },
1935 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1936 "force codec tag/fourcc", "fourcc/tag" },
1937 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1938 "use fixed quality scale (VBR)", "q" },
1939 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1940 "use fixed quality scale (VBR)", "q" },
1941 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1942 "set stream filterchain", "filter_list" },
1943 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1944 "create a complex filtergraph", "graph_description" },
1945 { "stats", OPT_BOOL, { &print_stats },
1946 "print progress report during encoding", },
1947 { "attach", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_attach },
1948 "add an attachment to the output file", "filename" },
1949 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1950 "extract an attachment into a file", "filename" },
1951 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1952 "set CPU flags mask", "mask" },
1955 { "vframes", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_frames },
1956 "set the number of video frames to record", "number" },
1957 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1958 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1959 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1960 "set frame size (WxH or abbreviation)", "size" },
1961 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1962 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1963 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1964 "set pixel format", "format" },
1965 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1967 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1968 "discard threshold", "n" },
1969 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1970 "rate control override for specific intervals", "override" },
1971 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_codec },
1972 "force video codec ('copy' to copy stream)", "codec" },
1973 { "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
1974 "use same quantizer as source (implies VBR)" },
1975 { "pass", OPT_VIDEO | HAS_ARG , { opt_pass },
1976 "select the pass number (1 or 2)", "n" },
1977 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT, { &pass_logfilename_prefix },
1978 "select two pass log file name prefix", "prefix" },
1979 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1980 "this option is deprecated, use the yadif filter instead" },
1981 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1982 "dump video coding statistics to file" },
1983 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1984 "dump video coding statistics to file", "file" },
1985 { "vf", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_filters },
1986 "video filters", "filter list" },
1987 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1988 "specify intra matrix coeffs", "matrix" },
1989 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1990 "specify inter matrix coeffs", "matrix" },
1991 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1992 "top=1/bottom=0/auto=-1 field first", "" },
1993 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1994 "intra_dc_precision", "precision" },
1995 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_video_tag },
1996 "force video tag/fourcc", "fourcc/tag" },
1997 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1998 "show QP histogram" },
1999 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2000 "force the selected framerate, disable the best supported framerate selection" },
2001 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_streamid },
2002 "set the value of an outfile streamid", "streamIndex:value" },
2003 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2004 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2007 { "aframes", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_frames },
2008 "set the number of audio frames to record", "number" },
2009 { "aq", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_qscale },
2010 "set audio quality (codec-specific)", "quality", },
2011 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2012 "set audio sampling rate (in Hz)", "rate" },
2013 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2014 "set number of audio channels", "channels" },
2015 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2017 { "acodec", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_codec },
2018 "force audio codec ('copy' to copy stream)", "codec" },
2019 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_audio_tag },
2020 "force audio tag/fourcc", "fourcc/tag" },
2021 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2022 "change audio volume (256=normal)" , "volume" },
2023 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2024 "set sample format", "format" },
2025 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_channel_layout },
2026 "set channel layout", "layout" },
2027 { "af", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_filters },
2028 "audio filters", "filter list" },
2030 /* subtitle options */
2031 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2032 "disable subtitle" },
2033 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_subtitle_codec },
2034 "force subtitle codec ('copy' to copy stream)", "codec" },
2035 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_subtitle_tag }
2036 , "force subtitle tag/fourcc", "fourcc/tag" },
2039 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2042 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2043 "set the maximum demux-decode delay", "seconds" },
2044 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2045 "set the initial demux-decode delay", "seconds" },
2047 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2048 "A comma-separated list of bitstream filters", "bitstream_filters" },
2050 /* data codec support */
2051 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_codec },
2052 "force data codec ('copy' to copy stream)", "codec" },
2054 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2055 "generic catch all option", "" },