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 *vstats_filename;
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold = 10;
62 int audio_volume = 256;
63 int audio_sync_method = 0;
64 int video_sync_method = VSYNC_AUTO;
65 int do_deinterlace = 0;
71 int exit_on_error = 0;
75 static int file_overwrite = 0;
76 static int video_discard = 0;
77 static int intra_dc_precision = 8;
78 static int using_stdin = 0;
79 static int input_sync;
81 void reset_options(OptionsContext *o)
83 const OptionDef *po = options;
86 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
88 void *dst = (uint8_t*)o + po->u.off;
90 if (po->flags & OPT_SPEC) {
91 SpecifierOpt **so = dst;
92 int i, *count = (int*)(so + 1);
93 for (i = 0; i < *count; i++) {
94 av_freep(&(*so)[i].specifier);
95 if (po->flags & OPT_STRING)
96 av_freep(&(*so)[i].u.str);
100 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
105 for (i = 0; i < o->nb_stream_maps; i++)
106 av_freep(&o->stream_maps[i].linklabel);
107 av_freep(&o->stream_maps);
108 av_freep(&o->meta_data_maps);
109 av_freep(&o->streamid_map);
111 memset(o, 0, sizeof(*o));
113 o->mux_max_delay = 0.7;
114 o->recording_time = INT64_MAX;
115 o->limit_filesize = UINT64_MAX;
116 o->chapters_input_file = INT_MAX;
123 static double parse_frame_aspect_ratio(const char *arg)
130 p = strchr(arg, ':');
132 x = strtol(arg, &end, 10);
134 y = strtol(end + 1, &end, 10);
136 ar = (double)x / (double)y;
138 ar = strtod(arg, NULL);
141 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
147 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
149 OptionsContext *o = optctx;
150 return parse_option(o, "codec:a", arg, options);
153 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
155 OptionsContext *o = optctx;
156 return parse_option(o, "codec:v", arg, options);
159 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
161 OptionsContext *o = optctx;
162 return parse_option(o, "codec:s", arg, options);
165 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
167 OptionsContext *o = optctx;
168 return parse_option(o, "codec:d", arg, options);
171 static int opt_map(void *optctx, const char *opt, const char *arg)
173 OptionsContext *o = optctx;
175 int i, negative = 0, file_idx;
176 int sync_file_idx = -1, sync_stream_idx;
184 map = av_strdup(arg);
186 /* parse sync stream first, just pick first matching stream */
187 if (sync = strchr(map, ',')) {
189 sync_file_idx = strtol(sync + 1, &sync, 0);
190 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
191 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
196 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
197 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
198 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
202 if (i == input_files[sync_file_idx]->nb_streams) {
203 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
204 "match any streams.\n", arg);
211 /* this mapping refers to lavfi output */
212 const char *c = map + 1;
213 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
214 &o->nb_stream_maps, o->nb_stream_maps + 1);
215 m = &o->stream_maps[o->nb_stream_maps - 1];
216 m->linklabel = av_get_token(&c, "]");
218 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
222 file_idx = strtol(map, &p, 0);
223 if (file_idx >= nb_input_files || file_idx < 0) {
224 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
228 /* disable some already defined maps */
229 for (i = 0; i < o->nb_stream_maps; i++) {
230 m = &o->stream_maps[i];
231 if (file_idx == m->file_index &&
232 check_stream_specifier(input_files[m->file_index]->ctx,
233 input_files[m->file_index]->ctx->streams[m->stream_index],
234 *p == ':' ? p + 1 : p) > 0)
238 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
239 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
240 *p == ':' ? p + 1 : p) <= 0)
242 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
243 &o->nb_stream_maps, o->nb_stream_maps + 1);
244 m = &o->stream_maps[o->nb_stream_maps - 1];
246 m->file_index = file_idx;
249 if (sync_file_idx >= 0) {
250 m->sync_file_index = sync_file_idx;
251 m->sync_stream_index = sync_stream_idx;
253 m->sync_file_index = file_idx;
254 m->sync_stream_index = i;
260 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
268 static int opt_attach(void *optctx, const char *opt, const char *arg)
270 OptionsContext *o = optctx;
271 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
272 &o->nb_attachments, o->nb_attachments + 1);
273 o->attachments[o->nb_attachments - 1] = arg;
278 * Parse a metadata specifier in arg.
279 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
280 * @param index for type c/p, chapter/program index is written here
281 * @param stream_spec for type s, the stream specifier is written here
283 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
291 if (*(++arg) && *arg != ':') {
292 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
295 *stream_spec = *arg == ':' ? arg + 1 : "";
300 *index = strtol(++arg, NULL, 0);
303 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
310 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
312 AVDictionary **meta_in = NULL;
313 AVDictionary **meta_out;
315 char type_in, type_out;
316 const char *istream_spec = NULL, *ostream_spec = NULL;
317 int idx_in = 0, idx_out = 0;
319 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
320 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
322 if (type_in == 'g' || type_out == 'g')
323 o->metadata_global_manual = 1;
324 if (type_in == 's' || type_out == 's')
325 o->metadata_streams_manual = 1;
326 if (type_in == 'c' || type_out == 'c')
327 o->metadata_chapters_manual = 1;
329 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
330 if ((index) < 0 || (index) >= (nb_elems)) {\
331 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
336 #define SET_DICT(type, meta, context, index)\
339 meta = &context->metadata;\
342 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
343 meta = &context->chapters[index]->metadata;\
346 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
347 meta = &context->programs[index]->metadata;\
349 default: av_assert0(0);\
352 SET_DICT(type_in, meta_in, ic, idx_in);
353 SET_DICT(type_out, meta_out, oc, idx_out);
355 /* for input streams choose first matching stream */
356 if (type_in == 's') {
357 for (i = 0; i < ic->nb_streams; i++) {
358 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
359 meta_in = &ic->streams[i]->metadata;
365 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
370 if (type_out == 's') {
371 for (i = 0; i < oc->nb_streams; i++) {
372 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
373 meta_out = &oc->streams[i]->metadata;
374 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
379 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
384 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
386 const AVCodecDescriptor *desc;
387 const char *codec_string = encoder ? "encoder" : "decoder";
391 avcodec_find_encoder_by_name(name) :
392 avcodec_find_decoder_by_name(name);
394 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
395 codec = encoder ? avcodec_find_encoder(desc->id) :
396 avcodec_find_decoder(desc->id);
398 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
399 codec_string, codec->name, desc->name);
403 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
406 if (codec->type != type) {
407 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
413 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
415 char *codec_name = NULL;
417 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
419 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
420 st->codec->codec_id = codec->id;
423 return avcodec_find_decoder(st->codec->codec_id);
427 * Add all the streams from the given input file to the global
428 * list of input streams.
430 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
434 for (i = 0; i < ic->nb_streams; i++) {
435 AVStream *st = ic->streams[i];
436 AVCodecContext *dec = st->codec;
437 InputStream *ist = av_mallocz(sizeof(*ist));
438 char *framerate = NULL;
443 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
444 input_streams[nb_input_streams - 1] = ist;
447 ist->file_index = nb_input_files;
449 st->discard = AVDISCARD_ALL;
450 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
453 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
455 ist->dec = choose_decoder(o, ic, st);
457 switch (dec->codec_type) {
458 case AVMEDIA_TYPE_VIDEO:
459 ist->resample_height = dec->height;
460 ist->resample_width = dec->width;
461 ist->resample_pix_fmt = dec->pix_fmt;
463 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
464 if (framerate && av_parse_video_rate(&ist->framerate,
466 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
472 case AVMEDIA_TYPE_AUDIO:
473 guess_input_channel_layout(ist);
475 ist->resample_sample_fmt = dec->sample_fmt;
476 ist->resample_sample_rate = dec->sample_rate;
477 ist->resample_channels = dec->channels;
478 ist->resample_channel_layout = dec->channel_layout;
481 case AVMEDIA_TYPE_DATA:
482 case AVMEDIA_TYPE_SUBTITLE:
483 case AVMEDIA_TYPE_ATTACHMENT:
484 case AVMEDIA_TYPE_UNKNOWN:
492 static void assert_file_overwrite(const char *filename)
494 if (!file_overwrite &&
495 (strchr(filename, ':') == NULL || filename[1] == ':' ||
496 av_strstart(filename, "file:", NULL))) {
497 if (avio_check(filename, 0) == 0) {
499 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
502 fprintf(stderr, "Not overwriting - exiting\n");
507 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
514 static void dump_attachment(AVStream *st, const char *filename)
517 AVIOContext *out = NULL;
518 AVDictionaryEntry *e;
520 if (!st->codec->extradata_size) {
521 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
522 nb_input_files - 1, st->index);
525 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
528 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
529 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
533 assert_file_overwrite(filename);
535 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
536 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
541 avio_write(out, st->codec->extradata, st->codec->extradata_size);
546 static int opt_input_file(void *optctx, const char *opt, const char *filename)
548 OptionsContext *o = optctx;
550 AVInputFormat *file_iformat = NULL;
555 int orig_nb_streams; // number of streams before avformat_find_stream_info
558 if (!(file_iformat = av_find_input_format(o->format))) {
559 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
564 if (!strcmp(filename, "-"))
567 using_stdin |= !strncmp(filename, "pipe:", 5) ||
568 !strcmp(filename, "/dev/stdin");
570 /* get default parameters from command line */
571 ic = avformat_alloc_context();
573 print_error(filename, AVERROR(ENOMEM));
576 if (o->nb_audio_sample_rate) {
577 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
578 av_dict_set(&format_opts, "sample_rate", buf, 0);
580 if (o->nb_audio_channels) {
581 /* because we set audio_channels based on both the "ac" and
582 * "channel_layout" options, we need to check that the specified
583 * demuxer actually has the "channels" option before setting it */
584 if (file_iformat && file_iformat->priv_class &&
585 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
586 AV_OPT_SEARCH_FAKE_OBJ)) {
587 snprintf(buf, sizeof(buf), "%d",
588 o->audio_channels[o->nb_audio_channels - 1].u.i);
589 av_dict_set(&format_opts, "channels", buf, 0);
592 if (o->nb_frame_rates) {
593 /* set the format-level framerate option;
594 * this is important for video grabbers, e.g. x11 */
595 if (file_iformat && file_iformat->priv_class &&
596 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
597 AV_OPT_SEARCH_FAKE_OBJ)) {
598 av_dict_set(&format_opts, "framerate",
599 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
602 if (o->nb_frame_sizes) {
603 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
605 if (o->nb_frame_pix_fmts)
606 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
608 ic->flags |= AVFMT_FLAG_NONBLOCK;
609 ic->interrupt_callback = int_cb;
611 /* open the input file with generic libav function */
612 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
614 print_error(filename, err);
617 assert_avoptions(format_opts);
619 /* apply forced codec ids */
620 for (i = 0; i < ic->nb_streams; i++)
621 choose_decoder(o, ic, ic->streams[i]);
623 /* Set AVCodecContext options for avformat_find_stream_info */
624 opts = setup_find_stream_info_opts(ic, codec_opts);
625 orig_nb_streams = ic->nb_streams;
627 /* If not enough info to get the stream parameters, we decode the
628 first frames to get it. (used in mpeg case for example) */
629 ret = avformat_find_stream_info(ic, opts);
631 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
632 avformat_close_input(&ic);
636 timestamp = o->start_time;
637 /* add the stream start time */
638 if (ic->start_time != AV_NOPTS_VALUE)
639 timestamp += ic->start_time;
641 /* if seeking requested, we execute it */
642 if (o->start_time != 0) {
643 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
645 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
646 filename, (double)timestamp / AV_TIME_BASE);
650 /* update the current parameters so that they match the one of the input stream */
651 add_input_streams(o, ic);
653 /* dump the file content */
654 av_dump_format(ic, nb_input_files, filename, 0);
656 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
657 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
660 input_files[nb_input_files - 1]->ctx = ic;
661 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
662 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
663 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
664 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
666 for (i = 0; i < o->nb_dump_attachment; i++) {
669 for (j = 0; j < ic->nb_streams; j++) {
670 AVStream *st = ic->streams[j];
672 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
673 dump_attachment(st, o->dump_attachment[i].u.str);
677 for (i = 0; i < orig_nb_streams; i++)
678 av_dict_free(&opts[i]);
685 static uint8_t *get_line(AVIOContext *s)
691 if (avio_open_dyn_buf(&line) < 0) {
692 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
696 while ((c = avio_r8(s)) && c != '\n')
699 avio_close_dyn_buf(line, &buf);
704 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
708 const char *base[3] = { getenv("AVCONV_DATADIR"),
713 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
717 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
718 i != 1 ? "" : "/.avconv", codec_name, preset_name);
719 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
722 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
723 i != 1 ? "" : "/.avconv", preset_name);
724 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
730 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
732 char *codec_name = NULL;
734 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
736 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
737 NULL, ost->st->codec->codec_type);
738 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
739 } else if (!strcmp(codec_name, "copy"))
740 ost->stream_copy = 1;
742 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
743 ost->st->codec->codec_id = ost->enc->id;
747 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
750 AVStream *st = avformat_new_stream(oc, NULL);
751 int idx = oc->nb_streams - 1, ret = 0;
752 char *bsf = NULL, *next, *codec_tag = NULL;
753 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
755 char *buf = NULL, *arg = NULL, *preset = NULL;
756 AVIOContext *s = NULL;
759 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
763 if (oc->nb_streams - 1 < o->nb_streamid_map)
764 st->id = o->streamid_map[oc->nb_streams - 1];
766 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
767 nb_output_streams + 1);
768 if (!(ost = av_mallocz(sizeof(*ost))))
770 output_streams[nb_output_streams - 1] = ost;
772 ost->file_index = nb_output_files;
775 st->codec->codec_type = type;
776 choose_encoder(o, oc, ost);
778 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
781 avcodec_get_context_defaults3(st->codec, ost->enc);
782 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
784 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
785 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
788 if (!buf[0] || buf[0] == '#') {
792 if (!(arg = strchr(buf, '='))) {
793 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
797 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
799 } while (!s->eof_reached);
803 av_log(NULL, AV_LOG_FATAL,
804 "Preset %s specified for stream %d:%d, but could not be opened.\n",
805 preset, ost->file_index, ost->index);
809 ost->max_frames = INT64_MAX;
810 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
812 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
814 if (next = strchr(bsf, ','))
816 if (!(bsfc = av_bitstream_filter_init(bsf))) {
817 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
821 bsfc_prev->next = bsfc;
823 ost->bitstream_filters = bsfc;
829 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
831 uint32_t tag = strtol(codec_tag, &next, 0);
833 tag = AV_RL32(codec_tag);
834 st->codec->codec_tag = tag;
837 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
839 st->codec->flags |= CODEC_FLAG_QSCALE;
840 st->codec->global_quality = FF_QP2LAMBDA * qscale;
843 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
844 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
846 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
848 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
853 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
863 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
870 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
874 AVCodecContext *video_enc;
876 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
878 video_enc = st->codec;
880 if (!ost->stream_copy) {
881 const char *p = NULL;
882 char *frame_rate = NULL, *frame_size = NULL;
883 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
884 char *intra_matrix = NULL, *inter_matrix = NULL;
885 const char *filters = "null";
889 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
890 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
891 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
895 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
896 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
897 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
901 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
902 if (frame_aspect_ratio)
903 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
905 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
906 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
907 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
910 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
912 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
914 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
915 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
918 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
920 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
922 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
923 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
926 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
929 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
930 for (i = 0; p; i++) {
932 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
934 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
937 video_enc->rc_override =
938 av_realloc(video_enc->rc_override,
939 sizeof(RcOverride) * (i + 1));
940 video_enc->rc_override[i].start_frame = start;
941 video_enc->rc_override[i].end_frame = end;
943 video_enc->rc_override[i].qscale = q;
944 video_enc->rc_override[i].quality_factor = 1.0;
947 video_enc->rc_override[i].qscale = 0;
948 video_enc->rc_override[i].quality_factor = -q/100.0;
953 video_enc->rc_override_count = i;
954 if (!video_enc->rc_initial_buffer_occupancy)
955 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
956 video_enc->intra_dc_precision = intra_dc_precision - 8;
959 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
962 video_enc->flags |= CODEC_FLAG_PASS1;
964 video_enc->flags |= CODEC_FLAG_PASS2;
968 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
969 if (ost->logfile_prefix &&
970 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
973 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
974 if (ost->forced_keyframes)
975 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
977 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
979 ost->top_field_first = -1;
980 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
982 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
983 ost->avfilter = av_strdup(filters);
985 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
991 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
995 AVCodecContext *audio_enc;
997 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1000 audio_enc = st->codec;
1001 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1003 if (!ost->stream_copy) {
1004 char *sample_fmt = NULL;
1005 const char *filters = "anull";
1007 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1009 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1011 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1012 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1016 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1018 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1019 ost->avfilter = av_strdup(filters);
1025 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1029 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1030 if (!ost->stream_copy) {
1031 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1038 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1040 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1041 ost->stream_copy = 1;
1045 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1049 AVCodecContext *subtitle_enc;
1051 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1053 subtitle_enc = st->codec;
1055 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1060 /* arg format is "output-stream-index:streamid-value". */
1061 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1063 OptionsContext *o = optctx;
1068 av_strlcpy(idx_str, arg, sizeof(idx_str));
1069 p = strchr(idx_str, ':');
1071 av_log(NULL, AV_LOG_FATAL,
1072 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1077 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1078 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1079 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1083 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1085 AVFormatContext *is = ifile->ctx;
1086 AVFormatContext *os = ofile->ctx;
1090 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1092 return AVERROR(ENOMEM);
1095 for (i = 0; i < is->nb_chapters; i++) {
1096 AVChapter *in_ch = is->chapters[i], *out_ch;
1097 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1098 AV_TIME_BASE_Q, in_ch->time_base);
1099 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1100 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1103 if (in_ch->end < ts_off)
1105 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1108 out_ch = av_mallocz(sizeof(AVChapter));
1110 return AVERROR(ENOMEM);
1112 out_ch->id = in_ch->id;
1113 out_ch->time_base = in_ch->time_base;
1114 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1115 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1118 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1120 os->chapters[os->nb_chapters++] = out_ch;
1125 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1126 AVFormatContext *oc)
1130 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1131 ofilter->out_tmp->pad_idx)) {
1132 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1133 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1135 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1140 ost->source_index = -1;
1141 ost->filter = ofilter;
1145 if (ost->stream_copy) {
1146 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1147 "which is fed from a complex filtergraph. Filtering and streamcopy "
1148 "cannot be used together.\n", ost->file_index, ost->index);
1152 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1153 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1156 avfilter_inout_free(&ofilter->out_tmp);
1159 static int configure_complex_filters(void)
1163 for (i = 0; i < nb_filtergraphs; i++)
1164 if (!filtergraphs[i]->graph &&
1165 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1170 void opt_output_file(void *optctx, const char *filename)
1172 OptionsContext *o = optctx;
1173 AVFormatContext *oc;
1175 AVOutputFormat *file_oformat;
1179 if (configure_complex_filters() < 0) {
1180 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1184 if (!strcmp(filename, "-"))
1187 oc = avformat_alloc_context();
1189 print_error(filename, AVERROR(ENOMEM));
1194 file_oformat = av_guess_format(o->format, NULL, NULL);
1195 if (!file_oformat) {
1196 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1200 file_oformat = av_guess_format(NULL, filename, NULL);
1201 if (!file_oformat) {
1202 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1208 oc->oformat = file_oformat;
1209 oc->interrupt_callback = int_cb;
1210 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1212 /* create streams for all unlabeled output pads */
1213 for (i = 0; i < nb_filtergraphs; i++) {
1214 FilterGraph *fg = filtergraphs[i];
1215 for (j = 0; j < fg->nb_outputs; j++) {
1216 OutputFilter *ofilter = fg->outputs[j];
1218 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1221 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1222 ofilter->out_tmp->pad_idx)) {
1223 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1224 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1225 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1227 init_output_filter(ofilter, o, oc);
1231 if (!o->nb_stream_maps) {
1232 /* pick the "best" stream of each type */
1233 #define NEW_STREAM(type, index)\
1235 ost = new_ ## type ## _stream(o, oc);\
1236 ost->source_index = index;\
1237 ost->sync_ist = input_streams[index];\
1238 input_streams[index]->discard = 0;\
1239 input_streams[index]->st->discard = AVDISCARD_NONE;\
1242 /* video: highest resolution */
1243 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1244 int area = 0, idx = -1;
1245 for (i = 0; i < nb_input_streams; i++) {
1246 ist = input_streams[i];
1247 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1248 ist->st->codec->width * ist->st->codec->height > area) {
1249 area = ist->st->codec->width * ist->st->codec->height;
1253 NEW_STREAM(video, idx);
1256 /* audio: most channels */
1257 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1258 int channels = 0, idx = -1;
1259 for (i = 0; i < nb_input_streams; i++) {
1260 ist = input_streams[i];
1261 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1262 ist->st->codec->channels > channels) {
1263 channels = ist->st->codec->channels;
1267 NEW_STREAM(audio, idx);
1270 /* subtitles: pick first */
1271 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1272 for (i = 0; i < nb_input_streams; i++)
1273 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1274 NEW_STREAM(subtitle, i);
1278 /* do something with data? */
1280 for (i = 0; i < o->nb_stream_maps; i++) {
1281 StreamMap *map = &o->stream_maps[i];
1286 if (map->linklabel) {
1288 OutputFilter *ofilter = NULL;
1291 for (j = 0; j < nb_filtergraphs; j++) {
1292 fg = filtergraphs[j];
1293 for (k = 0; k < fg->nb_outputs; k++) {
1294 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1295 if (out && !strcmp(out->name, map->linklabel)) {
1296 ofilter = fg->outputs[k];
1303 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1304 "in any defined filter graph.\n", map->linklabel);
1307 init_output_filter(ofilter, o, oc);
1309 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1310 switch (ist->st->codec->codec_type) {
1311 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1312 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1313 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1314 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1315 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1317 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1318 map->file_index, map->stream_index);
1322 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1323 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1324 map->sync_stream_index];
1326 ist->st->discard = AVDISCARD_NONE;
1331 /* handle attached files */
1332 for (i = 0; i < o->nb_attachments; i++) {
1334 uint8_t *attachment;
1338 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1343 if ((len = avio_size(pb)) <= 0) {
1344 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1348 if (!(attachment = av_malloc(len))) {
1349 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1353 avio_read(pb, attachment, len);
1355 ost = new_attachment_stream(o, oc);
1356 ost->stream_copy = 0;
1357 ost->source_index = -1;
1358 ost->attachment_filename = o->attachments[i];
1359 ost->st->codec->extradata = attachment;
1360 ost->st->codec->extradata_size = len;
1362 p = strrchr(o->attachments[i], '/');
1363 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1367 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1368 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1371 output_files[nb_output_files - 1]->ctx = oc;
1372 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1373 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1374 if (o->recording_time != INT64_MAX)
1375 oc->duration = o->recording_time;
1376 output_files[nb_output_files - 1]->start_time = o->start_time;
1377 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1378 output_files[nb_output_files - 1]->shortest = o->shortest;
1379 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1381 /* check filename in case of an image number is expected */
1382 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1383 if (!av_filename_number_test(oc->filename)) {
1384 print_error(oc->filename, AVERROR(EINVAL));
1389 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1390 /* test if it already exists to avoid losing precious files */
1391 assert_file_overwrite(filename);
1394 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1395 &oc->interrupt_callback,
1396 &output_files[nb_output_files - 1]->opts)) < 0) {
1397 print_error(filename, err);
1402 if (o->mux_preload) {
1404 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1405 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1407 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1408 oc->flags |= AVFMT_FLAG_NONBLOCK;
1411 for (i = 0; i < o->nb_metadata_map; i++) {
1413 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1415 if (in_file_index < 0)
1417 if (in_file_index >= nb_input_files) {
1418 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1421 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
1425 if (o->chapters_input_file >= nb_input_files) {
1426 if (o->chapters_input_file == INT_MAX) {
1427 /* copy chapters from the first input file that has them*/
1428 o->chapters_input_file = -1;
1429 for (i = 0; i < nb_input_files; i++)
1430 if (input_files[i]->ctx->nb_chapters) {
1431 o->chapters_input_file = i;
1435 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1436 o->chapters_input_file);
1440 if (o->chapters_input_file >= 0)
1441 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1442 !o->metadata_chapters_manual);
1444 /* copy global metadata by default */
1445 if (!o->metadata_global_manual && nb_input_files)
1446 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1447 AV_DICT_DONT_OVERWRITE);
1448 if (!o->metadata_streams_manual)
1449 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1451 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1453 ist = input_streams[output_streams[i]->source_index];
1454 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1457 /* process manually set metadata */
1458 for (i = 0; i < o->nb_metadata; i++) {
1461 const char *stream_spec;
1462 int index = 0, j, ret;
1464 val = strchr(o->metadata[i].u.str, '=');
1466 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1467 o->metadata[i].u.str);
1472 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1474 for (j = 0; j < oc->nb_streams; j++) {
1475 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1476 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1487 if (index < 0 || index >= oc->nb_chapters) {
1488 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1491 m = &oc->chapters[index]->metadata;
1494 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1497 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1504 static int opt_target(void *optctx, const char *opt, const char *arg)
1506 OptionsContext *o = optctx;
1507 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1508 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1510 if (!strncmp(arg, "pal-", 4)) {
1513 } else if (!strncmp(arg, "ntsc-", 5)) {
1516 } else if (!strncmp(arg, "film-", 5)) {
1520 /* Try to determine PAL/NTSC by peeking in the input files */
1521 if (nb_input_files) {
1523 for (j = 0; j < nb_input_files; j++) {
1524 for (i = 0; i < input_files[j]->nb_streams; i++) {
1525 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1526 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1528 fr = c->time_base.den * 1000 / c->time_base.num;
1532 } else if ((fr == 29970) || (fr == 23976)) {
1537 if (norm != UNKNOWN)
1541 if (norm != UNKNOWN)
1542 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1545 if (norm == UNKNOWN) {
1546 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1547 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1548 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1552 if (!strcmp(arg, "vcd")) {
1553 opt_video_codec(o, "c:v", "mpeg1video");
1554 opt_audio_codec(o, "c:a", "mp2");
1555 parse_option(o, "f", "vcd", options);
1557 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1558 parse_option(o, "r", frame_rates[norm], options);
1559 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1561 opt_default(NULL, "b", "1150000");
1562 opt_default(NULL, "maxrate", "1150000");
1563 opt_default(NULL, "minrate", "1150000");
1564 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1566 opt_default(NULL, "b:a", "224000");
1567 parse_option(o, "ar", "44100", options);
1568 parse_option(o, "ac", "2", options);
1570 opt_default(NULL, "packetsize", "2324");
1571 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1573 /* We have to offset the PTS, so that it is consistent with the SCR.
1574 SCR starts at 36000, but the first two packs contain only padding
1575 and the first pack from the other stream, respectively, may also have
1576 been written before.
1577 So the real data starts at SCR 36000+3*1200. */
1578 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1579 } else if (!strcmp(arg, "svcd")) {
1581 opt_video_codec(o, "c:v", "mpeg2video");
1582 opt_audio_codec(o, "c:a", "mp2");
1583 parse_option(o, "f", "svcd", options);
1585 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1586 parse_option(o, "r", frame_rates[norm], options);
1587 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1589 opt_default(NULL, "b", "2040000");
1590 opt_default(NULL, "maxrate", "2516000");
1591 opt_default(NULL, "minrate", "0"); // 1145000;
1592 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1593 opt_default(NULL, "flags", "+scan_offset");
1596 opt_default(NULL, "b:a", "224000");
1597 parse_option(o, "ar", "44100", options);
1599 opt_default(NULL, "packetsize", "2324");
1601 } else if (!strcmp(arg, "dvd")) {
1603 opt_video_codec(o, "c:v", "mpeg2video");
1604 opt_audio_codec(o, "c:a", "ac3");
1605 parse_option(o, "f", "dvd", options);
1607 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1608 parse_option(o, "r", frame_rates[norm], options);
1609 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1611 opt_default(NULL, "b", "6000000");
1612 opt_default(NULL, "maxrate", "9000000");
1613 opt_default(NULL, "minrate", "0"); // 1500000;
1614 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1616 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1617 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1619 opt_default(NULL, "b:a", "448000");
1620 parse_option(o, "ar", "48000", options);
1622 } else if (!strncmp(arg, "dv", 2)) {
1624 parse_option(o, "f", "dv", options);
1626 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1627 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1628 norm == PAL ? "yuv420p" : "yuv411p", options);
1629 parse_option(o, "r", frame_rates[norm], options);
1631 parse_option(o, "ar", "48000", options);
1632 parse_option(o, "ac", "2", options);
1635 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1636 return AVERROR(EINVAL);
1641 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1643 av_free (vstats_filename);
1644 vstats_filename = av_strdup (arg);
1648 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1651 time_t today2 = time(NULL);
1652 struct tm *today = localtime(&today2);
1654 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1656 return opt_vstats_file(NULL, opt, filename);
1659 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1661 OptionsContext *o = optctx;
1662 return parse_option(o, "frames:v", arg, options);
1665 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1667 OptionsContext *o = optctx;
1668 return parse_option(o, "frames:a", arg, options);
1671 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1673 OptionsContext *o = optctx;
1674 return parse_option(o, "frames:d", arg, options);
1677 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1679 OptionsContext *o = optctx;
1680 return parse_option(o, "tag:v", arg, options);
1683 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1685 OptionsContext *o = optctx;
1686 return parse_option(o, "tag:a", arg, options);
1689 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1691 OptionsContext *o = optctx;
1692 return parse_option(o, "tag:s", arg, options);
1695 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1697 OptionsContext *o = optctx;
1698 return parse_option(o, "filter:v", arg, options);
1701 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1703 OptionsContext *o = optctx;
1704 return parse_option(o, "filter:a", arg, options);
1707 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1709 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1710 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1711 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1713 if (video_sync_method == VSYNC_AUTO)
1714 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1718 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1720 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1725 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1727 int flags = av_parse_cpu_flags(arg);
1732 av_set_cpu_flags_mask(flags);
1736 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1738 OptionsContext *o = optctx;
1739 char layout_str[32];
1742 int ret, channels, ac_str_size;
1745 layout = av_get_channel_layout(arg);
1747 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1748 return AVERROR(EINVAL);
1750 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1751 ret = opt_default(NULL, opt, layout_str);
1755 /* set 'ac' option based on channel layout */
1756 channels = av_get_channel_layout_nb_channels(layout);
1757 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1758 stream_str = strchr(opt, ':');
1759 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1760 ac_str = av_mallocz(ac_str_size);
1762 return AVERROR(ENOMEM);
1763 av_strlcpy(ac_str, "ac", 3);
1765 av_strlcat(ac_str, stream_str, ac_str_size);
1766 ret = parse_option(o, ac_str, layout_str, options);
1772 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1774 OptionsContext *o = optctx;
1775 return parse_option(o, "q:a", arg, options);
1778 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1780 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1781 &nb_filtergraphs, nb_filtergraphs + 1);
1782 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1783 return AVERROR(ENOMEM);
1784 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1785 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1789 void show_help_default(const char *opt, const char *arg)
1791 /* per-file options have at least one of those set */
1792 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1793 int show_advanced = 0, show_avoptions = 0;
1796 if (!strcmp(opt, "long"))
1798 else if (!strcmp(opt, "full"))
1799 show_advanced = show_avoptions = 1;
1801 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1806 printf("Getting help:\n"
1807 " -h -- print basic options\n"
1808 " -h long -- print more options\n"
1809 " -h full -- print all options (including all format and codec specific options, very long)\n"
1810 " See man %s for detailed description of the options.\n"
1811 "\n", program_name);
1813 show_help_options(options, "Print help / information / capabilities:",
1816 show_help_options(options, "Global options (affect whole program "
1817 "instead of just one file:",
1818 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1820 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1821 per_file | OPT_EXIT, 0);
1823 show_help_options(options, "Per-file main options:", 0,
1824 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1825 OPT_EXIT, per_file);
1827 show_help_options(options, "Advanced per-file options:",
1828 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1830 show_help_options(options, "Video options:",
1831 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1833 show_help_options(options, "Advanced Video options:",
1834 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1836 show_help_options(options, "Audio options:",
1837 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1839 show_help_options(options, "Advanced Audio options:",
1840 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1841 show_help_options(options, "Subtitle options:",
1842 OPT_SUBTITLE, 0, 0);
1845 if (show_avoptions) {
1846 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1847 show_help_children(avcodec_get_class(), flags);
1848 show_help_children(avformat_get_class(), flags);
1849 show_help_children(sws_get_class(), flags);
1853 void show_usage(void)
1855 printf("Hyper fast Audio and Video encoder\n");
1856 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1861 #define OFFSET(x) offsetof(OptionsContext, x)
1862 const OptionDef options[] = {
1864 #include "cmdutils_common_opts.h"
1865 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1866 "force format", "fmt" },
1867 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
1868 "input file name", "filename" },
1869 { "y", OPT_BOOL, { &file_overwrite },
1870 "overwrite output files" },
1871 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1872 "codec name", "codec" },
1873 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1874 "codec name", "codec" },
1875 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1876 "preset name", "preset" },
1877 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1878 "set input stream mapping",
1879 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1880 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1881 "set metadata information of outfile from infile",
1882 "outfile[,metadata]:infile[,metadata]" },
1883 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1884 "set chapters mapping", "input_file_index" },
1885 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1886 "record or transcode \"duration\" seconds of audio/video",
1888 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1889 "set the limit file size in bytes", "limit_size" },
1890 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1891 "set the start time offset", "time_off" },
1892 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1893 "set the input ts offset", "time_off" },
1894 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1895 "set the input ts scale", "scale" },
1896 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1897 "add metadata", "string=string" },
1898 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1899 "set the number of data frames to record", "number" },
1900 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1901 "add timings for benchmarking" },
1902 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1903 "set max runtime in seconds", "limit" },
1904 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1905 "dump each input packet" },
1906 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1907 "when dumping packets, also dump the payload" },
1908 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1909 "read input at native frame rate", "" },
1910 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1911 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1912 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1913 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1914 "video sync method", "" },
1915 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1916 "audio sync method", "" },
1917 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1918 "audio drift threshold", "threshold" },
1919 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1920 "copy timestamps" },
1921 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1922 "copy input stream time base when stream copying" },
1923 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1924 "finish encoding within shortest input" },
1925 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1926 "timestamp discontinuity delta threshold", "threshold" },
1927 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1928 "exit on error", "error" },
1929 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1930 "copy initial non-keyframes" },
1931 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1932 "set the number of frames to record", "number" },
1933 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1934 "force codec tag/fourcc", "fourcc/tag" },
1935 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1936 "use fixed quality scale (VBR)", "q" },
1937 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1938 "use fixed quality scale (VBR)", "q" },
1939 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1940 "set stream filterchain", "filter_list" },
1941 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1942 "create a complex filtergraph", "graph_description" },
1943 { "stats", OPT_BOOL, { &print_stats },
1944 "print progress report during encoding", },
1945 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
1946 "add an attachment to the output file", "filename" },
1947 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1948 "extract an attachment into a file", "filename" },
1949 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1950 "set CPU flags mask", "mask" },
1953 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
1954 "set the number of video frames to record", "number" },
1955 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1956 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1957 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1958 "set frame size (WxH or abbreviation)", "size" },
1959 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1960 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1961 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1962 "set pixel format", "format" },
1963 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1965 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1966 "discard threshold", "n" },
1967 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1968 "rate control override for specific intervals", "override" },
1969 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
1970 "force video codec ('copy' to copy stream)", "codec" },
1971 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
1972 "select the pass number (1 or 2)", "n" },
1973 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
1974 "select two pass log file name prefix", "prefix" },
1975 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1976 "this option is deprecated, use the yadif filter instead" },
1977 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1978 "dump video coding statistics to file" },
1979 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1980 "dump video coding statistics to file", "file" },
1981 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
1982 "video filters", "filter list" },
1983 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1984 "specify intra matrix coeffs", "matrix" },
1985 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1986 "specify inter matrix coeffs", "matrix" },
1987 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1988 "top=1/bottom=0/auto=-1 field first", "" },
1989 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1990 "intra_dc_precision", "precision" },
1991 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
1992 "force video tag/fourcc", "fourcc/tag" },
1993 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1994 "show QP histogram" },
1995 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
1996 "force the selected framerate, disable the best supported framerate selection" },
1997 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
1998 "set the value of an outfile streamid", "streamIndex:value" },
1999 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2000 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2003 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2004 "set the number of audio frames to record", "number" },
2005 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2006 "set audio quality (codec-specific)", "quality", },
2007 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2008 "set audio sampling rate (in Hz)", "rate" },
2009 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2010 "set number of audio channels", "channels" },
2011 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2013 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2014 "force audio codec ('copy' to copy stream)", "codec" },
2015 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2016 "force audio tag/fourcc", "fourcc/tag" },
2017 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2018 "change audio volume (256=normal)" , "volume" },
2019 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2020 "set sample format", "format" },
2021 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2022 "set channel layout", "layout" },
2023 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2024 "audio filters", "filter list" },
2026 /* subtitle options */
2027 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2028 "disable subtitle" },
2029 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2030 "force subtitle codec ('copy' to copy stream)", "codec" },
2031 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2032 , "force subtitle tag/fourcc", "fourcc/tag" },
2035 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2038 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2039 "set the maximum demux-decode delay", "seconds" },
2040 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2041 "set the initial demux-decode delay", "seconds" },
2043 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2044 "A comma-separated list of bitstream filters", "bitstream_filters" },
2046 /* data codec support */
2047 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2048 "force data codec ('copy' to copy stream)", "codec" },
2050 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2051 "generic catch all option", "" },