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/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.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 passed as 'arg' parameter.
279 * @param arg metadata string to parse
280 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
281 * @param index for type c/p, chapter/program index is written here
282 * @param stream_spec for type s, the stream specifier is written here
284 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
292 if (*(++arg) && *arg != ':') {
293 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
296 *stream_spec = *arg == ':' ? arg + 1 : "";
301 *index = strtol(++arg, NULL, 0);
304 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
311 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
313 AVDictionary **meta_in = NULL;
314 AVDictionary **meta_out;
316 char type_in, type_out;
317 const char *istream_spec = NULL, *ostream_spec = NULL;
318 int idx_in = 0, idx_out = 0;
320 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
321 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
323 if (type_in == 'g' || type_out == 'g')
324 o->metadata_global_manual = 1;
325 if (type_in == 's' || type_out == 's')
326 o->metadata_streams_manual = 1;
327 if (type_in == 'c' || type_out == 'c')
328 o->metadata_chapters_manual = 1;
330 /* ic is NULL when just disabling automatic mappings */
334 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
335 if ((index) < 0 || (index) >= (nb_elems)) {\
336 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
341 #define SET_DICT(type, meta, context, index)\
344 meta = &context->metadata;\
347 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
348 meta = &context->chapters[index]->metadata;\
351 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
352 meta = &context->programs[index]->metadata;\
354 default: av_assert0(0);\
357 SET_DICT(type_in, meta_in, ic, idx_in);
358 SET_DICT(type_out, meta_out, oc, idx_out);
360 /* for input streams choose first matching stream */
361 if (type_in == 's') {
362 for (i = 0; i < ic->nb_streams; i++) {
363 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
364 meta_in = &ic->streams[i]->metadata;
370 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
375 if (type_out == 's') {
376 for (i = 0; i < oc->nb_streams; i++) {
377 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
378 meta_out = &oc->streams[i]->metadata;
379 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
384 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
389 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
391 const AVCodecDescriptor *desc;
392 const char *codec_string = encoder ? "encoder" : "decoder";
396 avcodec_find_encoder_by_name(name) :
397 avcodec_find_decoder_by_name(name);
399 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
400 codec = encoder ? avcodec_find_encoder(desc->id) :
401 avcodec_find_decoder(desc->id);
403 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
404 codec_string, codec->name, desc->name);
408 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
411 if (codec->type != type) {
412 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
418 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
420 char *codec_name = NULL;
422 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
424 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
425 st->codec->codec_id = codec->id;
428 return avcodec_find_decoder(st->codec->codec_id);
431 /* Add all the streams from the given input file to the global
432 * list of input streams. */
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;
760 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
764 if (oc->nb_streams - 1 < o->nb_streamid_map)
765 st->id = o->streamid_map[oc->nb_streams - 1];
767 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
768 nb_output_streams + 1);
769 if (!(ost = av_mallocz(sizeof(*ost))))
771 output_streams[nb_output_streams - 1] = ost;
773 ost->file_index = nb_output_files;
776 st->codec->codec_type = type;
777 choose_encoder(o, oc, ost);
779 AVIOContext *s = NULL;
780 char *buf = NULL, *arg = NULL, *preset = NULL;
782 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
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);
810 avcodec_get_context_defaults3(st->codec, ost->enc);
811 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
813 ost->max_frames = INT64_MAX;
814 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
816 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
818 if (next = strchr(bsf, ','))
820 if (!(bsfc = av_bitstream_filter_init(bsf))) {
821 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
825 bsfc_prev->next = bsfc;
827 ost->bitstream_filters = bsfc;
833 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
835 uint32_t tag = strtol(codec_tag, &next, 0);
837 tag = AV_RL32(codec_tag);
838 st->codec->codec_tag = tag;
841 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
843 st->codec->flags |= CODEC_FLAG_QSCALE;
844 st->codec->global_quality = FF_QP2LAMBDA * qscale;
847 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
848 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
850 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
852 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
857 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
867 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
874 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
878 AVCodecContext *video_enc;
880 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
882 video_enc = st->codec;
884 if (!ost->stream_copy) {
885 const char *p = NULL;
886 char *frame_rate = NULL, *frame_size = NULL;
887 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
888 char *intra_matrix = NULL, *inter_matrix = NULL;
889 const char *filters = "null";
893 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
894 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
895 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
899 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
900 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
901 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
905 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
906 if (frame_aspect_ratio)
907 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
909 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
910 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
911 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
914 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
916 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
918 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
919 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
922 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
924 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
926 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
927 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
930 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
933 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
934 for (i = 0; p; i++) {
936 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
938 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
941 video_enc->rc_override =
942 av_realloc(video_enc->rc_override,
943 sizeof(RcOverride) * (i + 1));
944 video_enc->rc_override[i].start_frame = start;
945 video_enc->rc_override[i].end_frame = end;
947 video_enc->rc_override[i].qscale = q;
948 video_enc->rc_override[i].quality_factor = 1.0;
951 video_enc->rc_override[i].qscale = 0;
952 video_enc->rc_override[i].quality_factor = -q/100.0;
957 video_enc->rc_override_count = i;
958 if (!video_enc->rc_initial_buffer_occupancy)
959 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
960 video_enc->intra_dc_precision = intra_dc_precision - 8;
963 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
966 video_enc->flags |= CODEC_FLAG_PASS1;
968 video_enc->flags |= CODEC_FLAG_PASS2;
972 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
973 if (ost->logfile_prefix &&
974 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
977 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
978 if (ost->forced_keyframes)
979 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
981 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
983 ost->top_field_first = -1;
984 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
986 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
987 ost->avfilter = av_strdup(filters);
989 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
995 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
999 AVCodecContext *audio_enc;
1001 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1004 audio_enc = st->codec;
1005 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1007 if (!ost->stream_copy) {
1008 char *sample_fmt = NULL;
1009 const char *filters = "anull";
1011 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1013 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1015 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1016 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1020 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1022 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1023 ost->avfilter = av_strdup(filters);
1029 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1033 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1034 if (!ost->stream_copy) {
1035 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1042 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1044 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1045 ost->stream_copy = 1;
1049 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1053 AVCodecContext *subtitle_enc;
1055 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1057 subtitle_enc = st->codec;
1059 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1064 /* arg format is "output-stream-index:streamid-value". */
1065 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1067 OptionsContext *o = optctx;
1072 av_strlcpy(idx_str, arg, sizeof(idx_str));
1073 p = strchr(idx_str, ':');
1075 av_log(NULL, AV_LOG_FATAL,
1076 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1081 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1082 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1083 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1087 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1089 AVFormatContext *is = ifile->ctx;
1090 AVFormatContext *os = ofile->ctx;
1094 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1096 return AVERROR(ENOMEM);
1099 for (i = 0; i < is->nb_chapters; i++) {
1100 AVChapter *in_ch = is->chapters[i], *out_ch;
1101 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1102 AV_TIME_BASE_Q, in_ch->time_base);
1103 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1104 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1107 if (in_ch->end < ts_off)
1109 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1112 out_ch = av_mallocz(sizeof(AVChapter));
1114 return AVERROR(ENOMEM);
1116 out_ch->id = in_ch->id;
1117 out_ch->time_base = in_ch->time_base;
1118 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1119 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1122 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1124 os->chapters[os->nb_chapters++] = out_ch;
1129 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1130 AVFormatContext *oc)
1134 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1135 ofilter->out_tmp->pad_idx)) {
1136 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1137 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1139 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1144 ost->source_index = -1;
1145 ost->filter = ofilter;
1149 if (ost->stream_copy) {
1150 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1151 "which is fed from a complex filtergraph. Filtering and streamcopy "
1152 "cannot be used together.\n", ost->file_index, ost->index);
1156 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1157 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1160 avfilter_inout_free(&ofilter->out_tmp);
1163 static int configure_complex_filters(void)
1167 for (i = 0; i < nb_filtergraphs; i++)
1168 if (!filtergraphs[i]->graph &&
1169 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1174 void opt_output_file(void *optctx, const char *filename)
1176 OptionsContext *o = optctx;
1177 AVFormatContext *oc;
1179 AVOutputFormat *file_oformat;
1183 if (configure_complex_filters() < 0) {
1184 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1188 if (!strcmp(filename, "-"))
1191 oc = avformat_alloc_context();
1193 print_error(filename, AVERROR(ENOMEM));
1198 file_oformat = av_guess_format(o->format, NULL, NULL);
1199 if (!file_oformat) {
1200 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1204 file_oformat = av_guess_format(NULL, filename, NULL);
1205 if (!file_oformat) {
1206 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1212 oc->oformat = file_oformat;
1213 oc->interrupt_callback = int_cb;
1214 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1216 /* create streams for all unlabeled output pads */
1217 for (i = 0; i < nb_filtergraphs; i++) {
1218 FilterGraph *fg = filtergraphs[i];
1219 for (j = 0; j < fg->nb_outputs; j++) {
1220 OutputFilter *ofilter = fg->outputs[j];
1222 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1225 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1226 ofilter->out_tmp->pad_idx)) {
1227 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1228 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1229 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1231 init_output_filter(ofilter, o, oc);
1235 if (!o->nb_stream_maps) {
1236 /* pick the "best" stream of each type */
1237 #define NEW_STREAM(type, index)\
1239 ost = new_ ## type ## _stream(o, oc);\
1240 ost->source_index = index;\
1241 ost->sync_ist = input_streams[index];\
1242 input_streams[index]->discard = 0;\
1243 input_streams[index]->st->discard = AVDISCARD_NONE;\
1246 /* video: highest resolution */
1247 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1248 int area = 0, idx = -1;
1249 for (i = 0; i < nb_input_streams; i++) {
1250 ist = input_streams[i];
1251 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1252 ist->st->codec->width * ist->st->codec->height > area) {
1253 area = ist->st->codec->width * ist->st->codec->height;
1257 NEW_STREAM(video, idx);
1260 /* audio: most channels */
1261 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1262 int channels = 0, idx = -1;
1263 for (i = 0; i < nb_input_streams; i++) {
1264 ist = input_streams[i];
1265 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1266 ist->st->codec->channels > channels) {
1267 channels = ist->st->codec->channels;
1271 NEW_STREAM(audio, idx);
1274 /* subtitles: pick first */
1275 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1276 for (i = 0; i < nb_input_streams; i++)
1277 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1278 NEW_STREAM(subtitle, i);
1282 /* do something with data? */
1284 for (i = 0; i < o->nb_stream_maps; i++) {
1285 StreamMap *map = &o->stream_maps[i];
1290 if (map->linklabel) {
1292 OutputFilter *ofilter = NULL;
1295 for (j = 0; j < nb_filtergraphs; j++) {
1296 fg = filtergraphs[j];
1297 for (k = 0; k < fg->nb_outputs; k++) {
1298 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1299 if (out && !strcmp(out->name, map->linklabel)) {
1300 ofilter = fg->outputs[k];
1307 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1308 "in any defined filter graph.\n", map->linklabel);
1311 init_output_filter(ofilter, o, oc);
1313 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1314 switch (ist->st->codec->codec_type) {
1315 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1316 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1317 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1318 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1319 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1321 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1322 map->file_index, map->stream_index);
1326 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1327 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1328 map->sync_stream_index];
1330 ist->st->discard = AVDISCARD_NONE;
1335 /* handle attached files */
1336 for (i = 0; i < o->nb_attachments; i++) {
1338 uint8_t *attachment;
1342 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1343 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1347 if ((len = avio_size(pb)) <= 0) {
1348 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1352 if (!(attachment = av_malloc(len))) {
1353 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1357 avio_read(pb, attachment, len);
1359 ost = new_attachment_stream(o, oc);
1360 ost->stream_copy = 0;
1361 ost->source_index = -1;
1362 ost->attachment_filename = o->attachments[i];
1363 ost->st->codec->extradata = attachment;
1364 ost->st->codec->extradata_size = len;
1366 p = strrchr(o->attachments[i], '/');
1367 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1371 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1372 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1375 output_files[nb_output_files - 1]->ctx = oc;
1376 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1377 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1378 if (o->recording_time != INT64_MAX)
1379 oc->duration = o->recording_time;
1380 output_files[nb_output_files - 1]->start_time = o->start_time;
1381 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1382 output_files[nb_output_files - 1]->shortest = o->shortest;
1383 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1385 /* check filename in case of an image number is expected */
1386 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1387 if (!av_filename_number_test(oc->filename)) {
1388 print_error(oc->filename, AVERROR(EINVAL));
1393 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1394 /* test if it already exists to avoid losing precious files */
1395 assert_file_overwrite(filename);
1398 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1399 &oc->interrupt_callback,
1400 &output_files[nb_output_files - 1]->opts)) < 0) {
1401 print_error(filename, err);
1406 if (o->mux_preload) {
1408 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1409 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1411 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1412 oc->flags |= AVFMT_FLAG_NONBLOCK;
1415 for (i = 0; i < o->nb_metadata_map; i++) {
1417 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1419 if (in_file_index >= nb_input_files) {
1420 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1423 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1424 in_file_index >= 0 ?
1425 input_files[in_file_index]->ctx : NULL, o);
1429 if (o->chapters_input_file >= nb_input_files) {
1430 if (o->chapters_input_file == INT_MAX) {
1431 /* copy chapters from the first input file that has them*/
1432 o->chapters_input_file = -1;
1433 for (i = 0; i < nb_input_files; i++)
1434 if (input_files[i]->ctx->nb_chapters) {
1435 o->chapters_input_file = i;
1439 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1440 o->chapters_input_file);
1444 if (o->chapters_input_file >= 0)
1445 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1446 !o->metadata_chapters_manual);
1448 /* copy global metadata by default */
1449 if (!o->metadata_global_manual && nb_input_files)
1450 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1451 AV_DICT_DONT_OVERWRITE);
1452 if (!o->metadata_streams_manual)
1453 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1455 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1457 ist = input_streams[output_streams[i]->source_index];
1458 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1461 /* process manually set metadata */
1462 for (i = 0; i < o->nb_metadata; i++) {
1465 const char *stream_spec;
1466 int index = 0, j, ret;
1468 val = strchr(o->metadata[i].u.str, '=');
1470 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1471 o->metadata[i].u.str);
1476 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1478 for (j = 0; j < oc->nb_streams; j++) {
1479 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1480 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1491 if (index < 0 || index >= oc->nb_chapters) {
1492 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1495 m = &oc->chapters[index]->metadata;
1498 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1501 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1508 static int opt_target(void *optctx, const char *opt, const char *arg)
1510 OptionsContext *o = optctx;
1511 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1512 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1514 if (!strncmp(arg, "pal-", 4)) {
1517 } else if (!strncmp(arg, "ntsc-", 5)) {
1520 } else if (!strncmp(arg, "film-", 5)) {
1524 /* Try to determine PAL/NTSC by peeking in the input files */
1525 if (nb_input_files) {
1527 for (j = 0; j < nb_input_files; j++) {
1528 for (i = 0; i < input_files[j]->nb_streams; i++) {
1529 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1530 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1532 fr = c->time_base.den * 1000 / c->time_base.num;
1536 } else if ((fr == 29970) || (fr == 23976)) {
1541 if (norm != UNKNOWN)
1545 if (norm != UNKNOWN)
1546 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1549 if (norm == UNKNOWN) {
1550 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1551 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1552 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1556 if (!strcmp(arg, "vcd")) {
1557 opt_video_codec(o, "c:v", "mpeg1video");
1558 opt_audio_codec(o, "c:a", "mp2");
1559 parse_option(o, "f", "vcd", options);
1561 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1562 parse_option(o, "r", frame_rates[norm], options);
1563 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1565 opt_default(NULL, "b", "1150000");
1566 opt_default(NULL, "maxrate", "1150000");
1567 opt_default(NULL, "minrate", "1150000");
1568 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1570 opt_default(NULL, "b:a", "224000");
1571 parse_option(o, "ar", "44100", options);
1572 parse_option(o, "ac", "2", options);
1574 opt_default(NULL, "packetsize", "2324");
1575 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1577 /* We have to offset the PTS, so that it is consistent with the SCR.
1578 SCR starts at 36000, but the first two packs contain only padding
1579 and the first pack from the other stream, respectively, may also have
1580 been written before.
1581 So the real data starts at SCR 36000+3*1200. */
1582 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1583 } else if (!strcmp(arg, "svcd")) {
1585 opt_video_codec(o, "c:v", "mpeg2video");
1586 opt_audio_codec(o, "c:a", "mp2");
1587 parse_option(o, "f", "svcd", options);
1589 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1590 parse_option(o, "r", frame_rates[norm], options);
1591 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1593 opt_default(NULL, "b", "2040000");
1594 opt_default(NULL, "maxrate", "2516000");
1595 opt_default(NULL, "minrate", "0"); // 1145000;
1596 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1597 opt_default(NULL, "flags", "+scan_offset");
1600 opt_default(NULL, "b:a", "224000");
1601 parse_option(o, "ar", "44100", options);
1603 opt_default(NULL, "packetsize", "2324");
1605 } else if (!strcmp(arg, "dvd")) {
1607 opt_video_codec(o, "c:v", "mpeg2video");
1608 opt_audio_codec(o, "c:a", "ac3");
1609 parse_option(o, "f", "dvd", options);
1611 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1612 parse_option(o, "r", frame_rates[norm], options);
1613 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1615 opt_default(NULL, "b", "6000000");
1616 opt_default(NULL, "maxrate", "9000000");
1617 opt_default(NULL, "minrate", "0"); // 1500000;
1618 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1620 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1621 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1623 opt_default(NULL, "b:a", "448000");
1624 parse_option(o, "ar", "48000", options);
1626 } else if (!strncmp(arg, "dv", 2)) {
1628 parse_option(o, "f", "dv", options);
1630 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1631 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1632 norm == PAL ? "yuv420p" : "yuv411p", options);
1633 parse_option(o, "r", frame_rates[norm], options);
1635 parse_option(o, "ar", "48000", options);
1636 parse_option(o, "ac", "2", options);
1639 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1640 return AVERROR(EINVAL);
1645 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1647 av_free (vstats_filename);
1648 vstats_filename = av_strdup (arg);
1652 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1655 time_t today2 = time(NULL);
1656 struct tm *today = localtime(&today2);
1658 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1660 return opt_vstats_file(NULL, opt, filename);
1663 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1665 OptionsContext *o = optctx;
1666 return parse_option(o, "frames:v", arg, options);
1669 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1671 OptionsContext *o = optctx;
1672 return parse_option(o, "frames:a", arg, options);
1675 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1677 OptionsContext *o = optctx;
1678 return parse_option(o, "frames:d", arg, options);
1681 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1683 OptionsContext *o = optctx;
1684 return parse_option(o, "tag:v", arg, options);
1687 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1689 OptionsContext *o = optctx;
1690 return parse_option(o, "tag:a", arg, options);
1693 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1695 OptionsContext *o = optctx;
1696 return parse_option(o, "tag:s", arg, options);
1699 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1701 OptionsContext *o = optctx;
1702 return parse_option(o, "filter:v", arg, options);
1705 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1707 OptionsContext *o = optctx;
1708 return parse_option(o, "filter:a", arg, options);
1711 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1713 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1714 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1715 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1717 if (video_sync_method == VSYNC_AUTO)
1718 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1722 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1724 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1729 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1731 int flags = av_parse_cpu_flags(arg);
1736 av_set_cpu_flags_mask(flags);
1740 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1742 OptionsContext *o = optctx;
1743 char layout_str[32];
1746 int ret, channels, ac_str_size;
1749 layout = av_get_channel_layout(arg);
1751 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1752 return AVERROR(EINVAL);
1754 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1755 ret = opt_default(NULL, opt, layout_str);
1759 /* set 'ac' option based on channel layout */
1760 channels = av_get_channel_layout_nb_channels(layout);
1761 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1762 stream_str = strchr(opt, ':');
1763 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1764 ac_str = av_mallocz(ac_str_size);
1766 return AVERROR(ENOMEM);
1767 av_strlcpy(ac_str, "ac", 3);
1769 av_strlcat(ac_str, stream_str, ac_str_size);
1770 ret = parse_option(o, ac_str, layout_str, options);
1776 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1778 OptionsContext *o = optctx;
1779 return parse_option(o, "q:a", arg, options);
1782 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1784 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1785 &nb_filtergraphs, nb_filtergraphs + 1);
1786 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1787 return AVERROR(ENOMEM);
1788 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1789 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1793 void show_help_default(const char *opt, const char *arg)
1795 /* per-file options have at least one of those set */
1796 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1797 int show_advanced = 0, show_avoptions = 0;
1800 if (!strcmp(opt, "long"))
1802 else if (!strcmp(opt, "full"))
1803 show_advanced = show_avoptions = 1;
1805 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1810 printf("Getting help:\n"
1811 " -h -- print basic options\n"
1812 " -h long -- print more options\n"
1813 " -h full -- print all options (including all format and codec specific options, very long)\n"
1814 " See man %s for detailed description of the options.\n"
1815 "\n", program_name);
1817 show_help_options(options, "Print help / information / capabilities:",
1820 show_help_options(options, "Global options (affect whole program "
1821 "instead of just one file:",
1822 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1824 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1825 per_file | OPT_EXIT, 0);
1827 show_help_options(options, "Per-file main options:", 0,
1828 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1829 OPT_EXIT, per_file);
1831 show_help_options(options, "Advanced per-file options:",
1832 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1834 show_help_options(options, "Video options:",
1835 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1837 show_help_options(options, "Advanced Video options:",
1838 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1840 show_help_options(options, "Audio options:",
1841 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1843 show_help_options(options, "Advanced Audio options:",
1844 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1845 show_help_options(options, "Subtitle options:",
1846 OPT_SUBTITLE, 0, 0);
1849 if (show_avoptions) {
1850 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1851 show_help_children(avcodec_get_class(), flags);
1852 show_help_children(avformat_get_class(), flags);
1853 show_help_children(sws_get_class(), flags);
1857 void show_usage(void)
1859 printf("Hyper fast Audio and Video encoder\n");
1860 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1865 #define OFFSET(x) offsetof(OptionsContext, x)
1866 const OptionDef options[] = {
1868 #include "cmdutils_common_opts.h"
1869 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1870 "force format", "fmt" },
1871 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
1872 "input file name", "filename" },
1873 { "y", OPT_BOOL, { &file_overwrite },
1874 "overwrite output files" },
1875 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1876 "codec name", "codec" },
1877 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1878 "codec name", "codec" },
1879 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1880 "preset name", "preset" },
1881 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1882 "set input stream mapping",
1883 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1884 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1885 "set metadata information of outfile from infile",
1886 "outfile[,metadata]:infile[,metadata]" },
1887 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1888 "set chapters mapping", "input_file_index" },
1889 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1890 "record or transcode \"duration\" seconds of audio/video",
1892 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1893 "set the limit file size in bytes", "limit_size" },
1894 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1895 "set the start time offset", "time_off" },
1896 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1897 "set the input ts offset", "time_off" },
1898 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1899 "set the input ts scale", "scale" },
1900 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1901 "add metadata", "string=string" },
1902 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1903 "set the number of data frames to record", "number" },
1904 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1905 "add timings for benchmarking" },
1906 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1907 "set max runtime in seconds", "limit" },
1908 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1909 "dump each input packet" },
1910 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1911 "when dumping packets, also dump the payload" },
1912 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1913 "read input at native frame rate", "" },
1914 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1915 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1916 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1917 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1918 "video sync method", "" },
1919 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1920 "audio sync method", "" },
1921 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1922 "audio drift threshold", "threshold" },
1923 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1924 "copy timestamps" },
1925 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1926 "copy input stream time base when stream copying" },
1927 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1928 "finish encoding within shortest input" },
1929 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1930 "timestamp discontinuity delta threshold", "threshold" },
1931 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1932 "exit on error", "error" },
1933 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1934 "copy initial non-keyframes" },
1935 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1936 "set the number of frames to record", "number" },
1937 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1938 "force codec tag/fourcc", "fourcc/tag" },
1939 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1940 "use fixed quality scale (VBR)", "q" },
1941 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1942 "use fixed quality scale (VBR)", "q" },
1943 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1944 "set stream filterchain", "filter_list" },
1945 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1946 "create a complex filtergraph", "graph_description" },
1947 { "stats", OPT_BOOL, { &print_stats },
1948 "print progress report during encoding", },
1949 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
1950 "add an attachment to the output file", "filename" },
1951 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1952 "extract an attachment into a file", "filename" },
1953 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1954 "set CPU flags mask", "mask" },
1957 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
1958 "set the number of video frames to record", "number" },
1959 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1960 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1961 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1962 "set frame size (WxH or abbreviation)", "size" },
1963 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1964 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1965 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1966 "set pixel format", "format" },
1967 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1969 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1970 "discard threshold", "n" },
1971 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1972 "rate control override for specific intervals", "override" },
1973 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
1974 "force video codec ('copy' to copy stream)", "codec" },
1975 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
1976 "select the pass number (1 or 2)", "n" },
1977 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
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_PERFILE, { .func_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_PERFILE, { .func_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_PERFILE, { .func_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_PERFILE, { .func_arg = opt_audio_frames },
2008 "set the number of audio frames to record", "number" },
2009 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_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_PERFILE, { .func_arg = opt_audio_codec },
2018 "force audio codec ('copy' to copy stream)", "codec" },
2019 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_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_PERFILE, { .func_arg = opt_channel_layout },
2026 "set channel layout", "layout" },
2027 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_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_PERFILE, { .func_arg = opt_subtitle_codec },
2034 "force subtitle codec ('copy' to copy stream)", "codec" },
2035 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_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_PERFILE | OPT_EXPERT, { .func_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", "" },