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;
76 static int file_overwrite = 0;
77 static int video_discard = 0;
78 static int intra_dc_precision = 8;
79 static int using_stdin = 0;
80 static int input_sync;
82 void reset_options(OptionsContext *o)
84 const OptionDef *po = options;
87 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
89 void *dst = (uint8_t*)o + po->u.off;
91 if (po->flags & OPT_SPEC) {
92 SpecifierOpt **so = dst;
93 int i, *count = (int*)(so + 1);
94 for (i = 0; i < *count; i++) {
95 av_freep(&(*so)[i].specifier);
96 if (po->flags & OPT_STRING)
97 av_freep(&(*so)[i].u.str);
101 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
106 for (i = 0; i < o->nb_stream_maps; i++)
107 av_freep(&o->stream_maps[i].linklabel);
108 av_freep(&o->stream_maps);
109 av_freep(&o->meta_data_maps);
110 av_freep(&o->streamid_map);
112 memset(o, 0, sizeof(*o));
114 o->mux_max_delay = 0.7;
115 o->recording_time = INT64_MAX;
116 o->limit_filesize = UINT64_MAX;
117 o->chapters_input_file = INT_MAX;
124 static double parse_frame_aspect_ratio(const char *arg)
131 p = strchr(arg, ':');
133 x = strtol(arg, &end, 10);
135 y = strtol(end + 1, &end, 10);
137 ar = (double)x / (double)y;
139 ar = strtod(arg, NULL);
142 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
148 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
150 OptionsContext *o = optctx;
151 return parse_option(o, "codec:a", arg, options);
154 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
156 OptionsContext *o = optctx;
157 return parse_option(o, "codec:v", arg, options);
160 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
162 OptionsContext *o = optctx;
163 return parse_option(o, "codec:s", arg, options);
166 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
168 OptionsContext *o = optctx;
169 return parse_option(o, "codec:d", arg, options);
172 static int opt_map(void *optctx, const char *opt, const char *arg)
174 OptionsContext *o = optctx;
176 int i, negative = 0, file_idx;
177 int sync_file_idx = -1, sync_stream_idx;
185 map = av_strdup(arg);
187 /* parse sync stream first, just pick first matching stream */
188 if (sync = strchr(map, ',')) {
190 sync_file_idx = strtol(sync + 1, &sync, 0);
191 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
192 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
197 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
198 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
199 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
203 if (i == input_files[sync_file_idx]->nb_streams) {
204 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
205 "match any streams.\n", arg);
212 /* this mapping refers to lavfi output */
213 const char *c = map + 1;
214 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
215 &o->nb_stream_maps, o->nb_stream_maps + 1);
216 m = &o->stream_maps[o->nb_stream_maps - 1];
217 m->linklabel = av_get_token(&c, "]");
219 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
223 file_idx = strtol(map, &p, 0);
224 if (file_idx >= nb_input_files || file_idx < 0) {
225 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
229 /* disable some already defined maps */
230 for (i = 0; i < o->nb_stream_maps; i++) {
231 m = &o->stream_maps[i];
232 if (file_idx == m->file_index &&
233 check_stream_specifier(input_files[m->file_index]->ctx,
234 input_files[m->file_index]->ctx->streams[m->stream_index],
235 *p == ':' ? p + 1 : p) > 0)
239 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
240 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
241 *p == ':' ? p + 1 : p) <= 0)
243 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
244 &o->nb_stream_maps, o->nb_stream_maps + 1);
245 m = &o->stream_maps[o->nb_stream_maps - 1];
247 m->file_index = file_idx;
250 if (sync_file_idx >= 0) {
251 m->sync_file_index = sync_file_idx;
252 m->sync_stream_index = sync_stream_idx;
254 m->sync_file_index = file_idx;
255 m->sync_stream_index = i;
261 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
269 static int opt_attach(void *optctx, const char *opt, const char *arg)
271 OptionsContext *o = optctx;
272 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
273 &o->nb_attachments, o->nb_attachments + 1);
274 o->attachments[o->nb_attachments - 1] = arg;
279 * Parse a metadata specifier in arg.
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 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
331 if ((index) < 0 || (index) >= (nb_elems)) {\
332 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
337 #define SET_DICT(type, meta, context, index)\
340 meta = &context->metadata;\
343 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
344 meta = &context->chapters[index]->metadata;\
347 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
348 meta = &context->programs[index]->metadata;\
350 default: av_assert0(0);\
353 SET_DICT(type_in, meta_in, ic, idx_in);
354 SET_DICT(type_out, meta_out, oc, idx_out);
356 /* for input streams choose first matching stream */
357 if (type_in == 's') {
358 for (i = 0; i < ic->nb_streams; i++) {
359 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
360 meta_in = &ic->streams[i]->metadata;
366 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
371 if (type_out == 's') {
372 for (i = 0; i < oc->nb_streams; i++) {
373 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
374 meta_out = &oc->streams[i]->metadata;
375 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
380 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
385 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
387 const AVCodecDescriptor *desc;
388 const char *codec_string = encoder ? "encoder" : "decoder";
392 avcodec_find_encoder_by_name(name) :
393 avcodec_find_decoder_by_name(name);
395 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
396 codec = encoder ? avcodec_find_encoder(desc->id) :
397 avcodec_find_decoder(desc->id);
399 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
400 codec_string, codec->name, desc->name);
404 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
407 if (codec->type != type) {
408 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
414 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
416 char *codec_name = NULL;
418 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
420 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
421 st->codec->codec_id = codec->id;
424 return avcodec_find_decoder(st->codec->codec_id);
428 * Add all the streams from the given input file to the global
429 * list of input streams.
431 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
435 for (i = 0; i < ic->nb_streams; i++) {
436 AVStream *st = ic->streams[i];
437 AVCodecContext *dec = st->codec;
438 InputStream *ist = av_mallocz(sizeof(*ist));
439 char *framerate = NULL;
444 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
445 input_streams[nb_input_streams - 1] = ist;
448 ist->file_index = nb_input_files;
450 st->discard = AVDISCARD_ALL;
451 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
454 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
456 ist->dec = choose_decoder(o, ic, st);
458 switch (dec->codec_type) {
459 case AVMEDIA_TYPE_VIDEO:
460 ist->resample_height = dec->height;
461 ist->resample_width = dec->width;
462 ist->resample_pix_fmt = dec->pix_fmt;
464 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
465 if (framerate && av_parse_video_rate(&ist->framerate,
467 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
473 case AVMEDIA_TYPE_AUDIO:
474 guess_input_channel_layout(ist);
476 ist->resample_sample_fmt = dec->sample_fmt;
477 ist->resample_sample_rate = dec->sample_rate;
478 ist->resample_channels = dec->channels;
479 ist->resample_channel_layout = dec->channel_layout;
482 case AVMEDIA_TYPE_DATA:
483 case AVMEDIA_TYPE_SUBTITLE:
484 case AVMEDIA_TYPE_ATTACHMENT:
485 case AVMEDIA_TYPE_UNKNOWN:
493 static void assert_file_overwrite(const char *filename)
495 if (!file_overwrite &&
496 (strchr(filename, ':') == NULL || filename[1] == ':' ||
497 av_strstart(filename, "file:", NULL))) {
498 if (avio_check(filename, 0) == 0) {
500 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
503 fprintf(stderr, "Not overwriting - exiting\n");
508 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
515 static void dump_attachment(AVStream *st, const char *filename)
518 AVIOContext *out = NULL;
519 AVDictionaryEntry *e;
521 if (!st->codec->extradata_size) {
522 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
523 nb_input_files - 1, st->index);
526 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
529 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
530 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
534 assert_file_overwrite(filename);
536 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
537 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
542 avio_write(out, st->codec->extradata, st->codec->extradata_size);
547 static int opt_input_file(void *optctx, const char *opt, const char *filename)
549 OptionsContext *o = optctx;
551 AVInputFormat *file_iformat = NULL;
556 int orig_nb_streams; // number of streams before avformat_find_stream_info
559 if (!(file_iformat = av_find_input_format(o->format))) {
560 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
565 if (!strcmp(filename, "-"))
568 using_stdin |= !strncmp(filename, "pipe:", 5) ||
569 !strcmp(filename, "/dev/stdin");
571 /* get default parameters from command line */
572 ic = avformat_alloc_context();
574 print_error(filename, AVERROR(ENOMEM));
577 if (o->nb_audio_sample_rate) {
578 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
579 av_dict_set(&format_opts, "sample_rate", buf, 0);
581 if (o->nb_audio_channels) {
582 /* because we set audio_channels based on both the "ac" and
583 * "channel_layout" options, we need to check that the specified
584 * demuxer actually has the "channels" option before setting it */
585 if (file_iformat && file_iformat->priv_class &&
586 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
587 AV_OPT_SEARCH_FAKE_OBJ)) {
588 snprintf(buf, sizeof(buf), "%d",
589 o->audio_channels[o->nb_audio_channels - 1].u.i);
590 av_dict_set(&format_opts, "channels", buf, 0);
593 if (o->nb_frame_rates) {
594 /* set the format-level framerate option;
595 * this is important for video grabbers, e.g. x11 */
596 if (file_iformat && file_iformat->priv_class &&
597 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
598 AV_OPT_SEARCH_FAKE_OBJ)) {
599 av_dict_set(&format_opts, "framerate",
600 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
603 if (o->nb_frame_sizes) {
604 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
606 if (o->nb_frame_pix_fmts)
607 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
609 ic->flags |= AVFMT_FLAG_NONBLOCK;
610 ic->interrupt_callback = int_cb;
612 /* open the input file with generic libav function */
613 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
615 print_error(filename, err);
618 assert_avoptions(format_opts);
620 /* apply forced codec ids */
621 for (i = 0; i < ic->nb_streams; i++)
622 choose_decoder(o, ic, ic->streams[i]);
624 /* Set AVCodecContext options for avformat_find_stream_info */
625 opts = setup_find_stream_info_opts(ic, codec_opts);
626 orig_nb_streams = ic->nb_streams;
628 /* If not enough info to get the stream parameters, we decode the
629 first frames to get it. (used in mpeg case for example) */
630 ret = avformat_find_stream_info(ic, opts);
632 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
633 avformat_close_input(&ic);
637 timestamp = o->start_time;
638 /* add the stream start time */
639 if (ic->start_time != AV_NOPTS_VALUE)
640 timestamp += ic->start_time;
642 /* if seeking requested, we execute it */
643 if (o->start_time != 0) {
644 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
646 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
647 filename, (double)timestamp / AV_TIME_BASE);
651 /* update the current parameters so that they match the one of the input stream */
652 add_input_streams(o, ic);
654 /* dump the file content */
655 av_dump_format(ic, nb_input_files, filename, 0);
657 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
658 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
661 input_files[nb_input_files - 1]->ctx = ic;
662 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
663 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
664 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
665 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
667 for (i = 0; i < o->nb_dump_attachment; i++) {
670 for (j = 0; j < ic->nb_streams; j++) {
671 AVStream *st = ic->streams[j];
673 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
674 dump_attachment(st, o->dump_attachment[i].u.str);
678 for (i = 0; i < orig_nb_streams; i++)
679 av_dict_free(&opts[i]);
686 static uint8_t *get_line(AVIOContext *s)
692 if (avio_open_dyn_buf(&line) < 0) {
693 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
697 while ((c = avio_r8(s)) && c != '\n')
700 avio_close_dyn_buf(line, &buf);
705 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
709 const char *base[3] = { getenv("AVCONV_DATADIR"),
714 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
718 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
719 i != 1 ? "" : "/.avconv", codec_name, preset_name);
720 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
723 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
724 i != 1 ? "" : "/.avconv", preset_name);
725 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
731 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
733 char *codec_name = NULL;
735 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
737 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
738 NULL, ost->st->codec->codec_type);
739 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
740 } else if (!strcmp(codec_name, "copy"))
741 ost->stream_copy = 1;
743 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
744 ost->st->codec->codec_id = ost->enc->id;
748 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
751 AVStream *st = avformat_new_stream(oc, NULL);
752 int idx = oc->nb_streams - 1, ret = 0;
753 char *bsf = NULL, *next, *codec_tag = NULL;
754 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
756 char *buf = NULL, *arg = NULL, *preset = NULL;
757 AVIOContext *s = 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 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
782 avcodec_get_context_defaults3(st->codec, ost->enc);
783 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
785 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
786 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
789 if (!buf[0] || buf[0] == '#') {
793 if (!(arg = strchr(buf, '='))) {
794 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
798 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
800 } while (!s->eof_reached);
804 av_log(NULL, AV_LOG_FATAL,
805 "Preset %s specified for stream %d:%d, but could not be opened.\n",
806 preset, ost->file_index, ost->index);
810 ost->max_frames = INT64_MAX;
811 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
813 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
815 if (next = strchr(bsf, ','))
817 if (!(bsfc = av_bitstream_filter_init(bsf))) {
818 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
822 bsfc_prev->next = bsfc;
824 ost->bitstream_filters = bsfc;
830 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
832 uint32_t tag = strtol(codec_tag, &next, 0);
834 tag = AV_RL32(codec_tag);
835 st->codec->codec_tag = tag;
838 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
839 if (qscale >= 0 || same_quant) {
840 st->codec->flags |= CODEC_FLAG_QSCALE;
841 st->codec->global_quality = FF_QP2LAMBDA * qscale;
844 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
845 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
847 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
849 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
854 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
864 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
871 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
875 AVCodecContext *video_enc;
877 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
879 video_enc = st->codec;
881 if (!ost->stream_copy) {
882 const char *p = NULL;
883 char *frame_rate = NULL, *frame_size = NULL;
884 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
885 char *intra_matrix = NULL, *inter_matrix = NULL;
886 const char *filters = "null";
890 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
891 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
892 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
896 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
897 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
898 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
902 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
903 if (frame_aspect_ratio)
904 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
906 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
907 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
908 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
911 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
913 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
915 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
916 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
919 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
921 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
923 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
924 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
927 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
930 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
931 for (i = 0; p; i++) {
933 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
935 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
938 video_enc->rc_override =
939 av_realloc(video_enc->rc_override,
940 sizeof(RcOverride) * (i + 1));
941 video_enc->rc_override[i].start_frame = start;
942 video_enc->rc_override[i].end_frame = end;
944 video_enc->rc_override[i].qscale = q;
945 video_enc->rc_override[i].quality_factor = 1.0;
948 video_enc->rc_override[i].qscale = 0;
949 video_enc->rc_override[i].quality_factor = -q/100.0;
954 video_enc->rc_override_count = i;
955 if (!video_enc->rc_initial_buffer_occupancy)
956 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
957 video_enc->intra_dc_precision = intra_dc_precision - 8;
960 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
963 video_enc->flags |= CODEC_FLAG_PASS1;
965 video_enc->flags |= CODEC_FLAG_PASS2;
969 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
970 if (ost->logfile_prefix &&
971 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
974 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
975 if (ost->forced_keyframes)
976 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
978 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
980 ost->top_field_first = -1;
981 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
983 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
984 ost->avfilter = av_strdup(filters);
986 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
992 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
996 AVCodecContext *audio_enc;
998 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1001 audio_enc = st->codec;
1002 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1004 if (!ost->stream_copy) {
1005 char *sample_fmt = NULL;
1006 const char *filters = "anull";
1008 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1010 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1012 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1013 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1017 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1019 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1020 ost->avfilter = av_strdup(filters);
1026 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1030 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1031 if (!ost->stream_copy) {
1032 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1039 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1041 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1042 ost->stream_copy = 1;
1046 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1050 AVCodecContext *subtitle_enc;
1052 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1054 subtitle_enc = st->codec;
1056 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1061 /* arg format is "output-stream-index:streamid-value". */
1062 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1064 OptionsContext *o = optctx;
1069 av_strlcpy(idx_str, arg, sizeof(idx_str));
1070 p = strchr(idx_str, ':');
1072 av_log(NULL, AV_LOG_FATAL,
1073 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1078 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1079 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1080 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1084 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1086 AVFormatContext *is = ifile->ctx;
1087 AVFormatContext *os = ofile->ctx;
1090 for (i = 0; i < is->nb_chapters; i++) {
1091 AVChapter *in_ch = is->chapters[i], *out_ch;
1092 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1093 AV_TIME_BASE_Q, in_ch->time_base);
1094 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1095 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1098 if (in_ch->end < ts_off)
1100 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1103 out_ch = av_mallocz(sizeof(AVChapter));
1105 return AVERROR(ENOMEM);
1107 out_ch->id = in_ch->id;
1108 out_ch->time_base = in_ch->time_base;
1109 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1110 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1113 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1116 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
1118 return AVERROR(ENOMEM);
1119 os->chapters[os->nb_chapters - 1] = out_ch;
1124 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1125 AVFormatContext *oc)
1129 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1130 ofilter->out_tmp->pad_idx)) {
1131 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1132 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1134 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1139 ost->source_index = -1;
1140 ost->filter = ofilter;
1144 if (ost->stream_copy) {
1145 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1146 "which is fed from a complex filtergraph. Filtering and streamcopy "
1147 "cannot be used together.\n", ost->file_index, ost->index);
1151 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1152 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1155 avfilter_inout_free(&ofilter->out_tmp);
1158 static int configure_complex_filters(void)
1162 for (i = 0; i < nb_filtergraphs; i++)
1163 if (!filtergraphs[i]->graph &&
1164 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1169 void opt_output_file(void *optctx, const char *filename)
1171 OptionsContext *o = optctx;
1172 AVFormatContext *oc;
1174 AVOutputFormat *file_oformat;
1178 if (configure_complex_filters() < 0) {
1179 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1183 if (!strcmp(filename, "-"))
1186 oc = avformat_alloc_context();
1188 print_error(filename, AVERROR(ENOMEM));
1193 file_oformat = av_guess_format(o->format, NULL, NULL);
1194 if (!file_oformat) {
1195 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1199 file_oformat = av_guess_format(NULL, filename, NULL);
1200 if (!file_oformat) {
1201 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1207 oc->oformat = file_oformat;
1208 oc->interrupt_callback = int_cb;
1209 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1211 /* create streams for all unlabeled output pads */
1212 for (i = 0; i < nb_filtergraphs; i++) {
1213 FilterGraph *fg = filtergraphs[i];
1214 for (j = 0; j < fg->nb_outputs; j++) {
1215 OutputFilter *ofilter = fg->outputs[j];
1217 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1220 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1221 ofilter->out_tmp->pad_idx)) {
1222 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1223 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1224 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1226 init_output_filter(ofilter, o, oc);
1230 if (!o->nb_stream_maps) {
1231 /* pick the "best" stream of each type */
1232 #define NEW_STREAM(type, index)\
1234 ost = new_ ## type ## _stream(o, oc);\
1235 ost->source_index = index;\
1236 ost->sync_ist = input_streams[index];\
1237 input_streams[index]->discard = 0;\
1238 input_streams[index]->st->discard = AVDISCARD_NONE;\
1241 /* video: highest resolution */
1242 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1243 int area = 0, idx = -1;
1244 for (i = 0; i < nb_input_streams; i++) {
1245 ist = input_streams[i];
1246 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1247 ist->st->codec->width * ist->st->codec->height > area) {
1248 area = ist->st->codec->width * ist->st->codec->height;
1252 NEW_STREAM(video, idx);
1255 /* audio: most channels */
1256 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1257 int channels = 0, idx = -1;
1258 for (i = 0; i < nb_input_streams; i++) {
1259 ist = input_streams[i];
1260 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1261 ist->st->codec->channels > channels) {
1262 channels = ist->st->codec->channels;
1266 NEW_STREAM(audio, idx);
1269 /* subtitles: pick first */
1270 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1271 for (i = 0; i < nb_input_streams; i++)
1272 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1273 NEW_STREAM(subtitle, i);
1277 /* do something with data? */
1279 for (i = 0; i < o->nb_stream_maps; i++) {
1280 StreamMap *map = &o->stream_maps[i];
1285 if (map->linklabel) {
1287 OutputFilter *ofilter = NULL;
1290 for (j = 0; j < nb_filtergraphs; j++) {
1291 fg = filtergraphs[j];
1292 for (k = 0; k < fg->nb_outputs; k++) {
1293 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1294 if (out && !strcmp(out->name, map->linklabel)) {
1295 ofilter = fg->outputs[k];
1302 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1303 "in any defined filter graph.\n", map->linklabel);
1306 init_output_filter(ofilter, o, oc);
1308 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1309 switch (ist->st->codec->codec_type) {
1310 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1311 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1312 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1313 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1314 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1316 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1317 map->file_index, map->stream_index);
1321 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1322 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1323 map->sync_stream_index];
1325 ist->st->discard = AVDISCARD_NONE;
1330 /* handle attached files */
1331 for (i = 0; i < o->nb_attachments; i++) {
1333 uint8_t *attachment;
1337 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1338 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1342 if ((len = avio_size(pb)) <= 0) {
1343 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1347 if (!(attachment = av_malloc(len))) {
1348 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1352 avio_read(pb, attachment, len);
1354 ost = new_attachment_stream(o, oc);
1355 ost->stream_copy = 0;
1356 ost->source_index = -1;
1357 ost->attachment_filename = o->attachments[i];
1358 ost->st->codec->extradata = attachment;
1359 ost->st->codec->extradata_size = len;
1361 p = strrchr(o->attachments[i], '/');
1362 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1366 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1367 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1370 output_files[nb_output_files - 1]->ctx = oc;
1371 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1372 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1373 if (o->recording_time != INT64_MAX)
1374 oc->duration = o->recording_time;
1375 output_files[nb_output_files - 1]->start_time = o->start_time;
1376 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1377 output_files[nb_output_files - 1]->shortest = o->shortest;
1378 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1380 /* check filename in case of an image number is expected */
1381 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1382 if (!av_filename_number_test(oc->filename)) {
1383 print_error(oc->filename, AVERROR(EINVAL));
1388 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1389 /* test if it already exists to avoid losing precious files */
1390 assert_file_overwrite(filename);
1393 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1394 &oc->interrupt_callback,
1395 &output_files[nb_output_files - 1]->opts)) < 0) {
1396 print_error(filename, err);
1401 if (o->mux_preload) {
1403 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1404 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1406 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1407 oc->flags |= AVFMT_FLAG_NONBLOCK;
1410 for (i = 0; i < o->nb_metadata_map; i++) {
1412 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1414 if (in_file_index < 0)
1416 if (in_file_index >= nb_input_files) {
1417 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1420 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
1424 if (o->chapters_input_file >= nb_input_files) {
1425 if (o->chapters_input_file == INT_MAX) {
1426 /* copy chapters from the first input file that has them*/
1427 o->chapters_input_file = -1;
1428 for (i = 0; i < nb_input_files; i++)
1429 if (input_files[i]->ctx->nb_chapters) {
1430 o->chapters_input_file = i;
1434 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1435 o->chapters_input_file);
1439 if (o->chapters_input_file >= 0)
1440 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1441 !o->metadata_chapters_manual);
1443 /* copy global metadata by default */
1444 if (!o->metadata_global_manual && nb_input_files)
1445 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1446 AV_DICT_DONT_OVERWRITE);
1447 if (!o->metadata_streams_manual)
1448 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1450 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1452 ist = input_streams[output_streams[i]->source_index];
1453 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1456 /* process manually set metadata */
1457 for (i = 0; i < o->nb_metadata; i++) {
1460 const char *stream_spec;
1461 int index = 0, j, ret;
1463 val = strchr(o->metadata[i].u.str, '=');
1465 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1466 o->metadata[i].u.str);
1471 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1473 for (j = 0; j < oc->nb_streams; j++) {
1474 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1475 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1486 if (index < 0 || index >= oc->nb_chapters) {
1487 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1490 m = &oc->chapters[index]->metadata;
1493 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1496 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1503 static int opt_target(void *optctx, const char *opt, const char *arg)
1505 OptionsContext *o = optctx;
1506 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1507 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1509 if (!strncmp(arg, "pal-", 4)) {
1512 } else if (!strncmp(arg, "ntsc-", 5)) {
1515 } else if (!strncmp(arg, "film-", 5)) {
1519 /* Try to determine PAL/NTSC by peeking in the input files */
1520 if (nb_input_files) {
1522 for (j = 0; j < nb_input_files; j++) {
1523 for (i = 0; i < input_files[j]->nb_streams; i++) {
1524 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1525 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1527 fr = c->time_base.den * 1000 / c->time_base.num;
1531 } else if ((fr == 29970) || (fr == 23976)) {
1536 if (norm != UNKNOWN)
1540 if (norm != UNKNOWN)
1541 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1544 if (norm == UNKNOWN) {
1545 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1546 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1547 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1551 if (!strcmp(arg, "vcd")) {
1552 opt_video_codec(o, "c:v", "mpeg1video");
1553 opt_audio_codec(o, "c:a", "mp2");
1554 parse_option(o, "f", "vcd", options);
1556 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1557 parse_option(o, "r", frame_rates[norm], options);
1558 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1560 opt_default(NULL, "b", "1150000");
1561 opt_default(NULL, "maxrate", "1150000");
1562 opt_default(NULL, "minrate", "1150000");
1563 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1565 opt_default(NULL, "b:a", "224000");
1566 parse_option(o, "ar", "44100", options);
1567 parse_option(o, "ac", "2", options);
1569 opt_default(NULL, "packetsize", "2324");
1570 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1572 /* We have to offset the PTS, so that it is consistent with the SCR.
1573 SCR starts at 36000, but the first two packs contain only padding
1574 and the first pack from the other stream, respectively, may also have
1575 been written before.
1576 So the real data starts at SCR 36000+3*1200. */
1577 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1578 } else if (!strcmp(arg, "svcd")) {
1580 opt_video_codec(o, "c:v", "mpeg2video");
1581 opt_audio_codec(o, "c:a", "mp2");
1582 parse_option(o, "f", "svcd", options);
1584 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1585 parse_option(o, "r", frame_rates[norm], options);
1586 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1588 opt_default(NULL, "b", "2040000");
1589 opt_default(NULL, "maxrate", "2516000");
1590 opt_default(NULL, "minrate", "0"); // 1145000;
1591 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1592 opt_default(NULL, "flags", "+scan_offset");
1595 opt_default(NULL, "b:a", "224000");
1596 parse_option(o, "ar", "44100", options);
1598 opt_default(NULL, "packetsize", "2324");
1600 } else if (!strcmp(arg, "dvd")) {
1602 opt_video_codec(o, "c:v", "mpeg2video");
1603 opt_audio_codec(o, "c:a", "ac3");
1604 parse_option(o, "f", "dvd", options);
1606 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1607 parse_option(o, "r", frame_rates[norm], options);
1608 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1610 opt_default(NULL, "b", "6000000");
1611 opt_default(NULL, "maxrate", "9000000");
1612 opt_default(NULL, "minrate", "0"); // 1500000;
1613 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1615 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1616 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1618 opt_default(NULL, "b:a", "448000");
1619 parse_option(o, "ar", "48000", options);
1621 } else if (!strncmp(arg, "dv", 2)) {
1623 parse_option(o, "f", "dv", options);
1625 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1626 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1627 norm == PAL ? "yuv420p" : "yuv411p", options);
1628 parse_option(o, "r", frame_rates[norm], options);
1630 parse_option(o, "ar", "48000", options);
1631 parse_option(o, "ac", "2", options);
1634 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1635 return AVERROR(EINVAL);
1640 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1642 av_free (vstats_filename);
1643 vstats_filename = av_strdup (arg);
1647 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1650 time_t today2 = time(NULL);
1651 struct tm *today = localtime(&today2);
1653 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1655 return opt_vstats_file(NULL, opt, filename);
1658 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1660 OptionsContext *o = optctx;
1661 return parse_option(o, "frames:v", arg, options);
1664 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1666 OptionsContext *o = optctx;
1667 return parse_option(o, "frames:a", arg, options);
1670 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1672 OptionsContext *o = optctx;
1673 return parse_option(o, "frames:d", arg, options);
1676 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1678 OptionsContext *o = optctx;
1679 return parse_option(o, "tag:v", arg, options);
1682 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1684 OptionsContext *o = optctx;
1685 return parse_option(o, "tag:a", arg, options);
1688 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1690 OptionsContext *o = optctx;
1691 return parse_option(o, "tag:s", arg, options);
1694 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1696 OptionsContext *o = optctx;
1697 return parse_option(o, "filter:v", arg, options);
1700 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1702 OptionsContext *o = optctx;
1703 return parse_option(o, "filter:a", arg, options);
1706 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1708 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1709 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1710 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1712 if (video_sync_method == VSYNC_AUTO)
1713 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1717 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1719 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1724 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1726 int flags = av_parse_cpu_flags(arg);
1731 av_set_cpu_flags_mask(flags);
1735 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1737 OptionsContext *o = optctx;
1738 char layout_str[32];
1741 int ret, channels, ac_str_size;
1744 layout = av_get_channel_layout(arg);
1746 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1747 return AVERROR(EINVAL);
1749 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1750 ret = opt_default(NULL, opt, layout_str);
1754 /* set 'ac' option based on channel layout */
1755 channels = av_get_channel_layout_nb_channels(layout);
1756 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1757 stream_str = strchr(opt, ':');
1758 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1759 ac_str = av_mallocz(ac_str_size);
1761 return AVERROR(ENOMEM);
1762 av_strlcpy(ac_str, "ac", 3);
1764 av_strlcat(ac_str, stream_str, ac_str_size);
1765 ret = parse_option(o, ac_str, layout_str, options);
1771 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1773 OptionsContext *o = optctx;
1774 return parse_option(o, "q:a", arg, options);
1777 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1779 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1780 &nb_filtergraphs, nb_filtergraphs + 1);
1781 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1782 return AVERROR(ENOMEM);
1783 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1784 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1788 void show_help_default(const char *opt, const char *arg)
1790 /* per-file options have at least one of those set */
1791 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1792 int show_advanced = 0, show_avoptions = 0;
1795 if (!strcmp(opt, "long"))
1797 else if (!strcmp(opt, "full"))
1798 show_advanced = show_avoptions = 1;
1800 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1805 printf("Getting help:\n"
1806 " -h -- print basic options\n"
1807 " -h long -- print more options\n"
1808 " -h full -- print all options (including all format and codec specific options, very long)\n"
1809 " See man %s for detailed description of the options.\n"
1810 "\n", program_name);
1812 show_help_options(options, "Print help / information / capabilities:",
1815 show_help_options(options, "Global options (affect whole program "
1816 "instead of just one file:",
1817 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1819 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1820 per_file | OPT_EXIT, 0);
1822 show_help_options(options, "Per-file main options:", 0,
1823 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1824 OPT_EXIT, per_file);
1826 show_help_options(options, "Advanced per-file options:",
1827 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1829 show_help_options(options, "Video options:",
1830 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1832 show_help_options(options, "Advanced Video options:",
1833 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1835 show_help_options(options, "Audio options:",
1836 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1838 show_help_options(options, "Advanced Audio options:",
1839 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1840 show_help_options(options, "Subtitle options:",
1841 OPT_SUBTITLE, 0, 0);
1844 if (show_avoptions) {
1845 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1846 show_help_children(avcodec_get_class(), flags);
1847 show_help_children(avformat_get_class(), flags);
1848 show_help_children(sws_get_class(), flags);
1852 void show_usage(void)
1854 printf("Hyper fast Audio and Video encoder\n");
1855 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1860 #define OFFSET(x) offsetof(OptionsContext, x)
1861 const OptionDef options[] = {
1863 #include "cmdutils_common_opts.h"
1864 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1865 "force format", "fmt" },
1866 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
1867 "input file name", "filename" },
1868 { "y", OPT_BOOL, { &file_overwrite },
1869 "overwrite output files" },
1870 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1871 "codec name", "codec" },
1872 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1873 "codec name", "codec" },
1874 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1875 "preset name", "preset" },
1876 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1877 "set input stream mapping",
1878 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1879 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1880 "set metadata information of outfile from infile",
1881 "outfile[,metadata]:infile[,metadata]" },
1882 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1883 "set chapters mapping", "input_file_index" },
1884 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1885 "record or transcode \"duration\" seconds of audio/video",
1887 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1888 "set the limit file size in bytes", "limit_size" },
1889 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1890 "set the start time offset", "time_off" },
1891 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1892 "set the input ts offset", "time_off" },
1893 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1894 "set the input ts scale", "scale" },
1895 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1896 "add metadata", "string=string" },
1897 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1898 "set the number of data frames to record", "number" },
1899 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1900 "add timings for benchmarking" },
1901 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1902 "set max runtime in seconds", "limit" },
1903 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1904 "dump each input packet" },
1905 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1906 "when dumping packets, also dump the payload" },
1907 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1908 "read input at native frame rate", "" },
1909 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1910 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1911 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1912 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1913 "video sync method", "" },
1914 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1915 "audio sync method", "" },
1916 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1917 "audio drift threshold", "threshold" },
1918 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1919 "copy timestamps" },
1920 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1921 "copy input stream time base when stream copying" },
1922 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1923 "finish encoding within shortest input" },
1924 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1925 "timestamp discontinuity delta threshold", "threshold" },
1926 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1927 "exit on error", "error" },
1928 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1929 "copy initial non-keyframes" },
1930 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1931 "set the number of frames to record", "number" },
1932 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1933 "force codec tag/fourcc", "fourcc/tag" },
1934 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1935 "use fixed quality scale (VBR)", "q" },
1936 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1937 "use fixed quality scale (VBR)", "q" },
1938 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1939 "set stream filterchain", "filter_list" },
1940 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1941 "create a complex filtergraph", "graph_description" },
1942 { "stats", OPT_BOOL, { &print_stats },
1943 "print progress report during encoding", },
1944 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
1945 "add an attachment to the output file", "filename" },
1946 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1947 "extract an attachment into a file", "filename" },
1948 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1949 "set CPU flags mask", "mask" },
1952 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
1953 "set the number of video frames to record", "number" },
1954 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1955 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1956 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1957 "set frame size (WxH or abbreviation)", "size" },
1958 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1959 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1960 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1961 "set pixel format", "format" },
1962 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1964 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1965 "discard threshold", "n" },
1966 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1967 "rate control override for specific intervals", "override" },
1968 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
1969 "force video codec ('copy' to copy stream)", "codec" },
1970 { "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
1971 "use same quantizer as source (implies VBR)" },
1972 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
1973 "select the pass number (1 or 2)", "n" },
1974 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
1975 "select two pass log file name prefix", "prefix" },
1976 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1977 "this option is deprecated, use the yadif filter instead" },
1978 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1979 "dump video coding statistics to file" },
1980 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1981 "dump video coding statistics to file", "file" },
1982 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
1983 "video filters", "filter list" },
1984 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1985 "specify intra matrix coeffs", "matrix" },
1986 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1987 "specify inter matrix coeffs", "matrix" },
1988 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1989 "top=1/bottom=0/auto=-1 field first", "" },
1990 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1991 "intra_dc_precision", "precision" },
1992 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
1993 "force video tag/fourcc", "fourcc/tag" },
1994 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1995 "show QP histogram" },
1996 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
1997 "force the selected framerate, disable the best supported framerate selection" },
1998 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
1999 "set the value of an outfile streamid", "streamIndex:value" },
2000 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2001 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2004 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2005 "set the number of audio frames to record", "number" },
2006 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2007 "set audio quality (codec-specific)", "quality", },
2008 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2009 "set audio sampling rate (in Hz)", "rate" },
2010 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2011 "set number of audio channels", "channels" },
2012 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2014 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2015 "force audio codec ('copy' to copy stream)", "codec" },
2016 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2017 "force audio tag/fourcc", "fourcc/tag" },
2018 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2019 "change audio volume (256=normal)" , "volume" },
2020 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2021 "set sample format", "format" },
2022 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2023 "set channel layout", "layout" },
2024 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2025 "audio filters", "filter list" },
2027 /* subtitle options */
2028 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2029 "disable subtitle" },
2030 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2031 "force subtitle codec ('copy' to copy stream)", "codec" },
2032 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2033 , "force subtitle tag/fourcc", "fourcc/tag" },
2036 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2039 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2040 "set the maximum demux-decode delay", "seconds" },
2041 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2042 "set the initial demux-decode delay", "seconds" },
2044 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2045 "A comma-separated list of bitstream filters", "bitstream_filters" },
2047 /* data codec support */
2048 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2049 "force data codec ('copy' to copy stream)", "codec" },
2051 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2052 "generic catch all option", "" },