2 * avconv option parsing
4 * This file is part of Libav.
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 char *vstats_filename;
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold = 10;
62 int audio_volume = 256;
63 int audio_sync_method = 0;
64 int video_sync_method = VSYNC_AUTO;
65 int do_deinterlace = 0;
71 int exit_on_error = 0;
75 static int file_overwrite = 0;
76 static int video_discard = 0;
77 static int intra_dc_precision = 8;
78 static int using_stdin = 0;
79 static int input_sync;
81 void reset_options(OptionsContext *o)
83 const OptionDef *po = options;
86 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
88 void *dst = (uint8_t*)o + po->u.off;
90 if (po->flags & OPT_SPEC) {
91 SpecifierOpt **so = dst;
92 int i, *count = (int*)(so + 1);
93 for (i = 0; i < *count; i++) {
94 av_freep(&(*so)[i].specifier);
95 if (po->flags & OPT_STRING)
96 av_freep(&(*so)[i].u.str);
100 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
105 for (i = 0; i < o->nb_stream_maps; i++)
106 av_freep(&o->stream_maps[i].linklabel);
107 av_freep(&o->stream_maps);
108 av_freep(&o->meta_data_maps);
109 av_freep(&o->streamid_map);
111 memset(o, 0, sizeof(*o));
113 o->mux_max_delay = 0.7;
114 o->recording_time = INT64_MAX;
115 o->limit_filesize = UINT64_MAX;
116 o->chapters_input_file = INT_MAX;
123 static double parse_frame_aspect_ratio(const char *arg)
130 p = strchr(arg, ':');
132 x = strtol(arg, &end, 10);
134 y = strtol(end + 1, &end, 10);
136 ar = (double)x / (double)y;
138 ar = strtod(arg, NULL);
141 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
147 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
149 OptionsContext *o = optctx;
150 return parse_option(o, "codec:a", arg, options);
153 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
155 OptionsContext *o = optctx;
156 return parse_option(o, "codec:v", arg, options);
159 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
161 OptionsContext *o = optctx;
162 return parse_option(o, "codec:s", arg, options);
165 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
167 OptionsContext *o = optctx;
168 return parse_option(o, "codec:d", arg, options);
171 static int opt_map(void *optctx, const char *opt, const char *arg)
173 OptionsContext *o = optctx;
175 int i, negative = 0, file_idx;
176 int sync_file_idx = -1, sync_stream_idx;
184 map = av_strdup(arg);
186 /* parse sync stream first, just pick first matching stream */
187 if (sync = strchr(map, ',')) {
189 sync_file_idx = strtol(sync + 1, &sync, 0);
190 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
191 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
196 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
197 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
198 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
202 if (i == input_files[sync_file_idx]->nb_streams) {
203 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
204 "match any streams.\n", arg);
211 /* this mapping refers to lavfi output */
212 const char *c = map + 1;
213 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
214 &o->nb_stream_maps, o->nb_stream_maps + 1);
215 m = &o->stream_maps[o->nb_stream_maps - 1];
216 m->linklabel = av_get_token(&c, "]");
218 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
222 file_idx = strtol(map, &p, 0);
223 if (file_idx >= nb_input_files || file_idx < 0) {
224 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
228 /* disable some already defined maps */
229 for (i = 0; i < o->nb_stream_maps; i++) {
230 m = &o->stream_maps[i];
231 if (file_idx == m->file_index &&
232 check_stream_specifier(input_files[m->file_index]->ctx,
233 input_files[m->file_index]->ctx->streams[m->stream_index],
234 *p == ':' ? p + 1 : p) > 0)
238 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
239 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
240 *p == ':' ? p + 1 : p) <= 0)
242 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
243 &o->nb_stream_maps, o->nb_stream_maps + 1);
244 m = &o->stream_maps[o->nb_stream_maps - 1];
246 m->file_index = file_idx;
249 if (sync_file_idx >= 0) {
250 m->sync_file_index = sync_file_idx;
251 m->sync_stream_index = sync_stream_idx;
253 m->sync_file_index = file_idx;
254 m->sync_stream_index = i;
260 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
268 static int opt_attach(void *optctx, const char *opt, const char *arg)
270 OptionsContext *o = optctx;
271 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
272 &o->nb_attachments, o->nb_attachments + 1);
273 o->attachments[o->nb_attachments - 1] = arg;
278 * Parse a metadata specifier passed as 'arg' parameter.
279 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
280 * @param index for type c/p, chapter/program index is written here
281 * @param stream_spec for type s, the stream specifier is written here
283 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
291 if (*(++arg) && *arg != ':') {
292 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
295 *stream_spec = *arg == ':' ? arg + 1 : "";
300 *index = strtol(++arg, NULL, 0);
303 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
310 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
312 AVDictionary **meta_in = NULL;
313 AVDictionary **meta_out;
315 char type_in, type_out;
316 const char *istream_spec = NULL, *ostream_spec = NULL;
317 int idx_in = 0, idx_out = 0;
319 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
320 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
322 if (type_in == 'g' || type_out == 'g')
323 o->metadata_global_manual = 1;
324 if (type_in == 's' || type_out == 's')
325 o->metadata_streams_manual = 1;
326 if (type_in == 'c' || type_out == 'c')
327 o->metadata_chapters_manual = 1;
329 /* ic is NULL when just disabling automatic mappings */
333 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
334 if ((index) < 0 || (index) >= (nb_elems)) {\
335 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
340 #define SET_DICT(type, meta, context, index)\
343 meta = &context->metadata;\
346 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
347 meta = &context->chapters[index]->metadata;\
350 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
351 meta = &context->programs[index]->metadata;\
353 default: av_assert0(0);\
356 SET_DICT(type_in, meta_in, ic, idx_in);
357 SET_DICT(type_out, meta_out, oc, idx_out);
359 /* for input streams choose first matching stream */
360 if (type_in == 's') {
361 for (i = 0; i < ic->nb_streams; i++) {
362 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
363 meta_in = &ic->streams[i]->metadata;
369 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
374 if (type_out == 's') {
375 for (i = 0; i < oc->nb_streams; i++) {
376 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
377 meta_out = &oc->streams[i]->metadata;
378 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
383 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
388 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
390 const AVCodecDescriptor *desc;
391 const char *codec_string = encoder ? "encoder" : "decoder";
395 avcodec_find_encoder_by_name(name) :
396 avcodec_find_decoder_by_name(name);
398 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
399 codec = encoder ? avcodec_find_encoder(desc->id) :
400 avcodec_find_decoder(desc->id);
402 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
403 codec_string, codec->name, desc->name);
407 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
410 if (codec->type != type) {
411 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
417 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
419 char *codec_name = NULL;
421 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
423 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
424 st->codec->codec_id = codec->id;
427 return avcodec_find_decoder(st->codec->codec_id);
430 /* Add all the streams from the given input file to the global
431 * list of input streams. */
432 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
436 for (i = 0; i < ic->nb_streams; i++) {
437 AVStream *st = ic->streams[i];
438 AVCodecContext *dec = st->codec;
439 InputStream *ist = av_mallocz(sizeof(*ist));
440 char *framerate = NULL;
445 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
446 input_streams[nb_input_streams - 1] = ist;
449 ist->file_index = nb_input_files;
451 st->discard = AVDISCARD_ALL;
452 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
455 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
457 ist->dec = choose_decoder(o, ic, st);
459 switch (dec->codec_type) {
460 case AVMEDIA_TYPE_VIDEO:
461 ist->resample_height = dec->height;
462 ist->resample_width = dec->width;
463 ist->resample_pix_fmt = dec->pix_fmt;
465 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
466 if (framerate && av_parse_video_rate(&ist->framerate,
468 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
474 case AVMEDIA_TYPE_AUDIO:
475 guess_input_channel_layout(ist);
477 ist->resample_sample_fmt = dec->sample_fmt;
478 ist->resample_sample_rate = dec->sample_rate;
479 ist->resample_channels = dec->channels;
480 ist->resample_channel_layout = dec->channel_layout;
483 case AVMEDIA_TYPE_DATA:
484 case AVMEDIA_TYPE_SUBTITLE:
485 case AVMEDIA_TYPE_ATTACHMENT:
486 case AVMEDIA_TYPE_UNKNOWN:
494 static void assert_file_overwrite(const char *filename)
496 if (!file_overwrite &&
497 (strchr(filename, ':') == NULL || filename[1] == ':' ||
498 av_strstart(filename, "file:", NULL))) {
499 if (avio_check(filename, 0) == 0) {
501 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
504 fprintf(stderr, "Not overwriting - exiting\n");
509 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
516 static void dump_attachment(AVStream *st, const char *filename)
519 AVIOContext *out = NULL;
520 AVDictionaryEntry *e;
522 if (!st->codec->extradata_size) {
523 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
524 nb_input_files - 1, st->index);
527 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
530 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
531 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
535 assert_file_overwrite(filename);
537 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
538 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
543 avio_write(out, st->codec->extradata, st->codec->extradata_size);
548 static int opt_input_file(void *optctx, const char *opt, const char *filename)
550 OptionsContext *o = optctx;
552 AVInputFormat *file_iformat = NULL;
557 int orig_nb_streams; // number of streams before avformat_find_stream_info
560 if (!(file_iformat = av_find_input_format(o->format))) {
561 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
566 if (!strcmp(filename, "-"))
569 using_stdin |= !strncmp(filename, "pipe:", 5) ||
570 !strcmp(filename, "/dev/stdin");
572 /* get default parameters from command line */
573 ic = avformat_alloc_context();
575 print_error(filename, AVERROR(ENOMEM));
578 if (o->nb_audio_sample_rate) {
579 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
580 av_dict_set(&format_opts, "sample_rate", buf, 0);
582 if (o->nb_audio_channels) {
583 /* because we set audio_channels based on both the "ac" and
584 * "channel_layout" options, we need to check that the specified
585 * demuxer actually has the "channels" option before setting it */
586 if (file_iformat && file_iformat->priv_class &&
587 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
588 AV_OPT_SEARCH_FAKE_OBJ)) {
589 snprintf(buf, sizeof(buf), "%d",
590 o->audio_channels[o->nb_audio_channels - 1].u.i);
591 av_dict_set(&format_opts, "channels", buf, 0);
594 if (o->nb_frame_rates) {
595 /* set the format-level framerate option;
596 * this is important for video grabbers, e.g. x11 */
597 if (file_iformat && file_iformat->priv_class &&
598 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
599 AV_OPT_SEARCH_FAKE_OBJ)) {
600 av_dict_set(&format_opts, "framerate",
601 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
604 if (o->nb_frame_sizes) {
605 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
607 if (o->nb_frame_pix_fmts)
608 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
610 ic->flags |= AVFMT_FLAG_NONBLOCK;
611 ic->interrupt_callback = int_cb;
613 /* open the input file with generic libav function */
614 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
616 print_error(filename, err);
619 assert_avoptions(format_opts);
621 /* apply forced codec ids */
622 for (i = 0; i < ic->nb_streams; i++)
623 choose_decoder(o, ic, ic->streams[i]);
625 /* Set AVCodecContext options for avformat_find_stream_info */
626 opts = setup_find_stream_info_opts(ic, codec_opts);
627 orig_nb_streams = ic->nb_streams;
629 /* If not enough info to get the stream parameters, we decode the
630 first frames to get it. (used in mpeg case for example) */
631 ret = avformat_find_stream_info(ic, opts);
633 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
634 avformat_close_input(&ic);
638 timestamp = o->start_time;
639 /* add the stream start time */
640 if (ic->start_time != AV_NOPTS_VALUE)
641 timestamp += ic->start_time;
643 /* if seeking requested, we execute it */
644 if (o->start_time != 0) {
645 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
647 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
648 filename, (double)timestamp / AV_TIME_BASE);
652 /* update the current parameters so that they match the one of the input stream */
653 add_input_streams(o, ic);
655 /* dump the file content */
656 av_dump_format(ic, nb_input_files, filename, 0);
658 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
659 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
662 input_files[nb_input_files - 1]->ctx = ic;
663 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
664 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
665 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
666 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
668 for (i = 0; i < o->nb_dump_attachment; i++) {
671 for (j = 0; j < ic->nb_streams; j++) {
672 AVStream *st = ic->streams[j];
674 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
675 dump_attachment(st, o->dump_attachment[i].u.str);
679 for (i = 0; i < orig_nb_streams; i++)
680 av_dict_free(&opts[i]);
687 static uint8_t *get_line(AVIOContext *s)
693 if (avio_open_dyn_buf(&line) < 0) {
694 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
698 while ((c = avio_r8(s)) && c != '\n')
701 avio_close_dyn_buf(line, &buf);
706 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
710 const char *base[3] = { getenv("AVCONV_DATADIR"),
715 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
719 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
720 i != 1 ? "" : "/.avconv", codec_name, preset_name);
721 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
724 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
725 i != 1 ? "" : "/.avconv", preset_name);
726 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
732 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
734 char *codec_name = NULL;
736 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
738 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
739 NULL, ost->st->codec->codec_type);
740 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
741 } else if (!strcmp(codec_name, "copy"))
742 ost->stream_copy = 1;
744 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
745 ost->st->codec->codec_id = ost->enc->id;
749 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
752 AVStream *st = avformat_new_stream(oc, NULL);
753 int idx = oc->nb_streams - 1, ret = 0;
754 char *bsf = NULL, *next, *codec_tag = NULL;
755 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
757 char *buf = NULL, *arg = NULL, *preset = NULL;
758 AVIOContext *s = NULL;
761 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
765 if (oc->nb_streams - 1 < o->nb_streamid_map)
766 st->id = o->streamid_map[oc->nb_streams - 1];
768 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
769 nb_output_streams + 1);
770 if (!(ost = av_mallocz(sizeof(*ost))))
772 output_streams[nb_output_streams - 1] = ost;
774 ost->file_index = nb_output_files;
777 st->codec->codec_type = type;
778 choose_encoder(o, oc, ost);
780 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
783 avcodec_get_context_defaults3(st->codec, ost->enc);
784 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
786 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
787 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
790 if (!buf[0] || buf[0] == '#') {
794 if (!(arg = strchr(buf, '='))) {
795 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
799 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
801 } while (!s->eof_reached);
805 av_log(NULL, AV_LOG_FATAL,
806 "Preset %s specified for stream %d:%d, but could not be opened.\n",
807 preset, ost->file_index, ost->index);
811 ost->max_frames = INT64_MAX;
812 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
814 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
816 if (next = strchr(bsf, ','))
818 if (!(bsfc = av_bitstream_filter_init(bsf))) {
819 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
823 bsfc_prev->next = bsfc;
825 ost->bitstream_filters = bsfc;
831 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
833 uint32_t tag = strtol(codec_tag, &next, 0);
835 tag = AV_RL32(codec_tag);
836 st->codec->codec_tag = tag;
839 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
841 st->codec->flags |= CODEC_FLAG_QSCALE;
842 st->codec->global_quality = FF_QP2LAMBDA * qscale;
845 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
846 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
848 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
850 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
855 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
865 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
872 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
876 AVCodecContext *video_enc;
878 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
880 video_enc = st->codec;
882 if (!ost->stream_copy) {
883 const char *p = NULL;
884 char *frame_rate = NULL, *frame_size = NULL;
885 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
886 char *intra_matrix = NULL, *inter_matrix = NULL;
887 const char *filters = "null";
891 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
892 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
897 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
898 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
899 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
903 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
904 if (frame_aspect_ratio)
905 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
907 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
908 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
909 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
912 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
914 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
916 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
917 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
920 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
922 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
924 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
925 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
928 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
931 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
932 for (i = 0; p; i++) {
934 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
936 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
939 video_enc->rc_override =
940 av_realloc(video_enc->rc_override,
941 sizeof(RcOverride) * (i + 1));
942 video_enc->rc_override[i].start_frame = start;
943 video_enc->rc_override[i].end_frame = end;
945 video_enc->rc_override[i].qscale = q;
946 video_enc->rc_override[i].quality_factor = 1.0;
949 video_enc->rc_override[i].qscale = 0;
950 video_enc->rc_override[i].quality_factor = -q/100.0;
955 video_enc->rc_override_count = i;
956 if (!video_enc->rc_initial_buffer_occupancy)
957 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
958 video_enc->intra_dc_precision = intra_dc_precision - 8;
961 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
964 video_enc->flags |= CODEC_FLAG_PASS1;
966 video_enc->flags |= CODEC_FLAG_PASS2;
970 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
971 if (ost->logfile_prefix &&
972 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
975 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
976 if (ost->forced_keyframes)
977 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
979 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
981 ost->top_field_first = -1;
982 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
984 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
985 ost->avfilter = av_strdup(filters);
987 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
993 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
997 AVCodecContext *audio_enc;
999 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1002 audio_enc = st->codec;
1003 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1005 if (!ost->stream_copy) {
1006 char *sample_fmt = NULL;
1007 const char *filters = "anull";
1009 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1011 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1013 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1014 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1018 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1020 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1021 ost->avfilter = av_strdup(filters);
1027 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1031 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1032 if (!ost->stream_copy) {
1033 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1040 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1042 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1043 ost->stream_copy = 1;
1047 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1051 AVCodecContext *subtitle_enc;
1053 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1055 subtitle_enc = st->codec;
1057 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1062 /* arg format is "output-stream-index:streamid-value". */
1063 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1065 OptionsContext *o = optctx;
1070 av_strlcpy(idx_str, arg, sizeof(idx_str));
1071 p = strchr(idx_str, ':');
1073 av_log(NULL, AV_LOG_FATAL,
1074 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1079 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1080 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1081 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1085 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1087 AVFormatContext *is = ifile->ctx;
1088 AVFormatContext *os = ofile->ctx;
1092 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1094 return AVERROR(ENOMEM);
1097 for (i = 0; i < is->nb_chapters; i++) {
1098 AVChapter *in_ch = is->chapters[i], *out_ch;
1099 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1100 AV_TIME_BASE_Q, in_ch->time_base);
1101 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1102 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1105 if (in_ch->end < ts_off)
1107 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1110 out_ch = av_mallocz(sizeof(AVChapter));
1112 return AVERROR(ENOMEM);
1114 out_ch->id = in_ch->id;
1115 out_ch->time_base = in_ch->time_base;
1116 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1117 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1120 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1122 os->chapters[os->nb_chapters++] = out_ch;
1127 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1128 AVFormatContext *oc)
1132 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1133 ofilter->out_tmp->pad_idx)) {
1134 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1135 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1137 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1142 ost->source_index = -1;
1143 ost->filter = ofilter;
1147 if (ost->stream_copy) {
1148 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1149 "which is fed from a complex filtergraph. Filtering and streamcopy "
1150 "cannot be used together.\n", ost->file_index, ost->index);
1154 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1155 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1158 avfilter_inout_free(&ofilter->out_tmp);
1161 static int configure_complex_filters(void)
1165 for (i = 0; i < nb_filtergraphs; i++)
1166 if (!filtergraphs[i]->graph &&
1167 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1172 void opt_output_file(void *optctx, const char *filename)
1174 OptionsContext *o = optctx;
1175 AVFormatContext *oc;
1177 AVOutputFormat *file_oformat;
1181 if (configure_complex_filters() < 0) {
1182 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1186 if (!strcmp(filename, "-"))
1189 oc = avformat_alloc_context();
1191 print_error(filename, AVERROR(ENOMEM));
1196 file_oformat = av_guess_format(o->format, NULL, NULL);
1197 if (!file_oformat) {
1198 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1202 file_oformat = av_guess_format(NULL, filename, NULL);
1203 if (!file_oformat) {
1204 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1210 oc->oformat = file_oformat;
1211 oc->interrupt_callback = int_cb;
1212 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1214 /* create streams for all unlabeled output pads */
1215 for (i = 0; i < nb_filtergraphs; i++) {
1216 FilterGraph *fg = filtergraphs[i];
1217 for (j = 0; j < fg->nb_outputs; j++) {
1218 OutputFilter *ofilter = fg->outputs[j];
1220 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1223 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1224 ofilter->out_tmp->pad_idx)) {
1225 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1226 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1227 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1229 init_output_filter(ofilter, o, oc);
1233 if (!o->nb_stream_maps) {
1234 /* pick the "best" stream of each type */
1235 #define NEW_STREAM(type, index)\
1237 ost = new_ ## type ## _stream(o, oc);\
1238 ost->source_index = index;\
1239 ost->sync_ist = input_streams[index];\
1240 input_streams[index]->discard = 0;\
1241 input_streams[index]->st->discard = AVDISCARD_NONE;\
1244 /* video: highest resolution */
1245 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1246 int area = 0, idx = -1;
1247 for (i = 0; i < nb_input_streams; i++) {
1248 ist = input_streams[i];
1249 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1250 ist->st->codec->width * ist->st->codec->height > area) {
1251 area = ist->st->codec->width * ist->st->codec->height;
1255 NEW_STREAM(video, idx);
1258 /* audio: most channels */
1259 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1260 int channels = 0, idx = -1;
1261 for (i = 0; i < nb_input_streams; i++) {
1262 ist = input_streams[i];
1263 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1264 ist->st->codec->channels > channels) {
1265 channels = ist->st->codec->channels;
1269 NEW_STREAM(audio, idx);
1272 /* subtitles: pick first */
1273 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1274 for (i = 0; i < nb_input_streams; i++)
1275 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1276 NEW_STREAM(subtitle, i);
1280 /* do something with data? */
1282 for (i = 0; i < o->nb_stream_maps; i++) {
1283 StreamMap *map = &o->stream_maps[i];
1288 if (map->linklabel) {
1290 OutputFilter *ofilter = NULL;
1293 for (j = 0; j < nb_filtergraphs; j++) {
1294 fg = filtergraphs[j];
1295 for (k = 0; k < fg->nb_outputs; k++) {
1296 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1297 if (out && !strcmp(out->name, map->linklabel)) {
1298 ofilter = fg->outputs[k];
1305 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1306 "in any defined filter graph.\n", map->linklabel);
1309 init_output_filter(ofilter, o, oc);
1311 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1312 switch (ist->st->codec->codec_type) {
1313 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1314 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1315 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1316 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1317 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1319 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1320 map->file_index, map->stream_index);
1324 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1325 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1326 map->sync_stream_index];
1328 ist->st->discard = AVDISCARD_NONE;
1333 /* handle attached files */
1334 for (i = 0; i < o->nb_attachments; i++) {
1336 uint8_t *attachment;
1340 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1341 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1345 if ((len = avio_size(pb)) <= 0) {
1346 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1350 if (!(attachment = av_malloc(len))) {
1351 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1355 avio_read(pb, attachment, len);
1357 ost = new_attachment_stream(o, oc);
1358 ost->stream_copy = 0;
1359 ost->source_index = -1;
1360 ost->attachment_filename = o->attachments[i];
1361 ost->st->codec->extradata = attachment;
1362 ost->st->codec->extradata_size = len;
1364 p = strrchr(o->attachments[i], '/');
1365 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1369 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1370 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1373 output_files[nb_output_files - 1]->ctx = oc;
1374 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1375 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1376 if (o->recording_time != INT64_MAX)
1377 oc->duration = o->recording_time;
1378 output_files[nb_output_files - 1]->start_time = o->start_time;
1379 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1380 output_files[nb_output_files - 1]->shortest = o->shortest;
1381 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1383 /* check filename in case of an image number is expected */
1384 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1385 if (!av_filename_number_test(oc->filename)) {
1386 print_error(oc->filename, AVERROR(EINVAL));
1391 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1392 /* test if it already exists to avoid losing precious files */
1393 assert_file_overwrite(filename);
1396 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1397 &oc->interrupt_callback,
1398 &output_files[nb_output_files - 1]->opts)) < 0) {
1399 print_error(filename, err);
1404 if (o->mux_preload) {
1406 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1407 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1409 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1410 oc->flags |= AVFMT_FLAG_NONBLOCK;
1413 for (i = 0; i < o->nb_metadata_map; i++) {
1415 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1417 if (in_file_index >= nb_input_files) {
1418 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1421 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1422 in_file_index >= 0 ?
1423 input_files[in_file_index]->ctx : NULL, o);
1427 if (o->chapters_input_file >= nb_input_files) {
1428 if (o->chapters_input_file == INT_MAX) {
1429 /* copy chapters from the first input file that has them*/
1430 o->chapters_input_file = -1;
1431 for (i = 0; i < nb_input_files; i++)
1432 if (input_files[i]->ctx->nb_chapters) {
1433 o->chapters_input_file = i;
1437 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1438 o->chapters_input_file);
1442 if (o->chapters_input_file >= 0)
1443 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1444 !o->metadata_chapters_manual);
1446 /* copy global metadata by default */
1447 if (!o->metadata_global_manual && nb_input_files)
1448 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1449 AV_DICT_DONT_OVERWRITE);
1450 if (!o->metadata_streams_manual)
1451 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1453 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1455 ist = input_streams[output_streams[i]->source_index];
1456 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1459 /* process manually set metadata */
1460 for (i = 0; i < o->nb_metadata; i++) {
1463 const char *stream_spec;
1464 int index = 0, j, ret;
1466 val = strchr(o->metadata[i].u.str, '=');
1468 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1469 o->metadata[i].u.str);
1474 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1476 for (j = 0; j < oc->nb_streams; j++) {
1477 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1478 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1489 if (index < 0 || index >= oc->nb_chapters) {
1490 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1493 m = &oc->chapters[index]->metadata;
1496 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1499 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1506 static int opt_target(void *optctx, const char *opt, const char *arg)
1508 OptionsContext *o = optctx;
1509 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1510 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1512 if (!strncmp(arg, "pal-", 4)) {
1515 } else if (!strncmp(arg, "ntsc-", 5)) {
1518 } else if (!strncmp(arg, "film-", 5)) {
1522 /* Try to determine PAL/NTSC by peeking in the input files */
1523 if (nb_input_files) {
1525 for (j = 0; j < nb_input_files; j++) {
1526 for (i = 0; i < input_files[j]->nb_streams; i++) {
1527 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1528 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1530 fr = c->time_base.den * 1000 / c->time_base.num;
1534 } else if ((fr == 29970) || (fr == 23976)) {
1539 if (norm != UNKNOWN)
1543 if (norm != UNKNOWN)
1544 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1547 if (norm == UNKNOWN) {
1548 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1549 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1550 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1554 if (!strcmp(arg, "vcd")) {
1555 opt_video_codec(o, "c:v", "mpeg1video");
1556 opt_audio_codec(o, "c:a", "mp2");
1557 parse_option(o, "f", "vcd", options);
1559 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1560 parse_option(o, "r", frame_rates[norm], options);
1561 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1563 opt_default(NULL, "b", "1150000");
1564 opt_default(NULL, "maxrate", "1150000");
1565 opt_default(NULL, "minrate", "1150000");
1566 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1568 opt_default(NULL, "b:a", "224000");
1569 parse_option(o, "ar", "44100", options);
1570 parse_option(o, "ac", "2", options);
1572 opt_default(NULL, "packetsize", "2324");
1573 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1575 /* We have to offset the PTS, so that it is consistent with the SCR.
1576 SCR starts at 36000, but the first two packs contain only padding
1577 and the first pack from the other stream, respectively, may also have
1578 been written before.
1579 So the real data starts at SCR 36000+3*1200. */
1580 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1581 } else if (!strcmp(arg, "svcd")) {
1583 opt_video_codec(o, "c:v", "mpeg2video");
1584 opt_audio_codec(o, "c:a", "mp2");
1585 parse_option(o, "f", "svcd", options);
1587 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1588 parse_option(o, "r", frame_rates[norm], options);
1589 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1591 opt_default(NULL, "b", "2040000");
1592 opt_default(NULL, "maxrate", "2516000");
1593 opt_default(NULL, "minrate", "0"); // 1145000;
1594 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1595 opt_default(NULL, "flags", "+scan_offset");
1598 opt_default(NULL, "b:a", "224000");
1599 parse_option(o, "ar", "44100", options);
1601 opt_default(NULL, "packetsize", "2324");
1603 } else if (!strcmp(arg, "dvd")) {
1605 opt_video_codec(o, "c:v", "mpeg2video");
1606 opt_audio_codec(o, "c:a", "ac3");
1607 parse_option(o, "f", "dvd", options);
1609 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1610 parse_option(o, "r", frame_rates[norm], options);
1611 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1613 opt_default(NULL, "b", "6000000");
1614 opt_default(NULL, "maxrate", "9000000");
1615 opt_default(NULL, "minrate", "0"); // 1500000;
1616 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1618 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1619 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1621 opt_default(NULL, "b:a", "448000");
1622 parse_option(o, "ar", "48000", options);
1624 } else if (!strncmp(arg, "dv", 2)) {
1626 parse_option(o, "f", "dv", options);
1628 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1629 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1630 norm == PAL ? "yuv420p" : "yuv411p", options);
1631 parse_option(o, "r", frame_rates[norm], options);
1633 parse_option(o, "ar", "48000", options);
1634 parse_option(o, "ac", "2", options);
1637 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1638 return AVERROR(EINVAL);
1643 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1645 av_free (vstats_filename);
1646 vstats_filename = av_strdup (arg);
1650 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1653 time_t today2 = time(NULL);
1654 struct tm *today = localtime(&today2);
1656 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1658 return opt_vstats_file(NULL, opt, filename);
1661 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1663 OptionsContext *o = optctx;
1664 return parse_option(o, "frames:v", arg, options);
1667 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1669 OptionsContext *o = optctx;
1670 return parse_option(o, "frames:a", arg, options);
1673 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1675 OptionsContext *o = optctx;
1676 return parse_option(o, "frames:d", arg, options);
1679 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1681 OptionsContext *o = optctx;
1682 return parse_option(o, "tag:v", arg, options);
1685 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1687 OptionsContext *o = optctx;
1688 return parse_option(o, "tag:a", arg, options);
1691 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1693 OptionsContext *o = optctx;
1694 return parse_option(o, "tag:s", arg, options);
1697 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1699 OptionsContext *o = optctx;
1700 return parse_option(o, "filter:v", arg, options);
1703 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1705 OptionsContext *o = optctx;
1706 return parse_option(o, "filter:a", arg, options);
1709 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1711 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1712 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1713 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1715 if (video_sync_method == VSYNC_AUTO)
1716 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1720 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1722 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1727 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1729 int flags = av_parse_cpu_flags(arg);
1734 av_set_cpu_flags_mask(flags);
1738 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1740 OptionsContext *o = optctx;
1741 char layout_str[32];
1744 int ret, channels, ac_str_size;
1747 layout = av_get_channel_layout(arg);
1749 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1750 return AVERROR(EINVAL);
1752 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1753 ret = opt_default(NULL, opt, layout_str);
1757 /* set 'ac' option based on channel layout */
1758 channels = av_get_channel_layout_nb_channels(layout);
1759 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1760 stream_str = strchr(opt, ':');
1761 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1762 ac_str = av_mallocz(ac_str_size);
1764 return AVERROR(ENOMEM);
1765 av_strlcpy(ac_str, "ac", 3);
1767 av_strlcat(ac_str, stream_str, ac_str_size);
1768 ret = parse_option(o, ac_str, layout_str, options);
1774 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1776 OptionsContext *o = optctx;
1777 return parse_option(o, "q:a", arg, options);
1780 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1782 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1783 &nb_filtergraphs, nb_filtergraphs + 1);
1784 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1785 return AVERROR(ENOMEM);
1786 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1787 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1791 void show_help_default(const char *opt, const char *arg)
1793 /* per-file options have at least one of those set */
1794 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1795 int show_advanced = 0, show_avoptions = 0;
1798 if (!strcmp(opt, "long"))
1800 else if (!strcmp(opt, "full"))
1801 show_advanced = show_avoptions = 1;
1803 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1808 printf("Getting help:\n"
1809 " -h -- print basic options\n"
1810 " -h long -- print more options\n"
1811 " -h full -- print all options (including all format and codec specific options, very long)\n"
1812 " See man %s for detailed description of the options.\n"
1813 "\n", program_name);
1815 show_help_options(options, "Print help / information / capabilities:",
1818 show_help_options(options, "Global options (affect whole program "
1819 "instead of just one file:",
1820 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1822 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1823 per_file | OPT_EXIT, 0);
1825 show_help_options(options, "Per-file main options:", 0,
1826 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1827 OPT_EXIT, per_file);
1829 show_help_options(options, "Advanced per-file options:",
1830 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1832 show_help_options(options, "Video options:",
1833 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1835 show_help_options(options, "Advanced Video options:",
1836 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1838 show_help_options(options, "Audio options:",
1839 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1841 show_help_options(options, "Advanced Audio options:",
1842 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1843 show_help_options(options, "Subtitle options:",
1844 OPT_SUBTITLE, 0, 0);
1847 if (show_avoptions) {
1848 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1849 show_help_children(avcodec_get_class(), flags);
1850 show_help_children(avformat_get_class(), flags);
1851 show_help_children(sws_get_class(), flags);
1855 void show_usage(void)
1857 printf("Hyper fast Audio and Video encoder\n");
1858 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1863 #define OFFSET(x) offsetof(OptionsContext, x)
1864 const OptionDef options[] = {
1866 #include "cmdutils_common_opts.h"
1867 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1868 "force format", "fmt" },
1869 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
1870 "input file name", "filename" },
1871 { "y", OPT_BOOL, { &file_overwrite },
1872 "overwrite output files" },
1873 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1874 "codec name", "codec" },
1875 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1876 "codec name", "codec" },
1877 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1878 "preset name", "preset" },
1879 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1880 "set input stream mapping",
1881 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1882 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1883 "set metadata information of outfile from infile",
1884 "outfile[,metadata]:infile[,metadata]" },
1885 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1886 "set chapters mapping", "input_file_index" },
1887 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1888 "record or transcode \"duration\" seconds of audio/video",
1890 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1891 "set the limit file size in bytes", "limit_size" },
1892 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1893 "set the start time offset", "time_off" },
1894 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1895 "set the input ts offset", "time_off" },
1896 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1897 "set the input ts scale", "scale" },
1898 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1899 "add metadata", "string=string" },
1900 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1901 "set the number of data frames to record", "number" },
1902 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1903 "add timings for benchmarking" },
1904 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1905 "set max runtime in seconds", "limit" },
1906 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1907 "dump each input packet" },
1908 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1909 "when dumping packets, also dump the payload" },
1910 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1911 "read input at native frame rate", "" },
1912 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1913 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1914 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1915 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1916 "video sync method", "" },
1917 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1918 "audio sync method", "" },
1919 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1920 "audio drift threshold", "threshold" },
1921 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1922 "copy timestamps" },
1923 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1924 "copy input stream time base when stream copying" },
1925 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1926 "finish encoding within shortest input" },
1927 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1928 "timestamp discontinuity delta threshold", "threshold" },
1929 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1930 "exit on error", "error" },
1931 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1932 "copy initial non-keyframes" },
1933 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1934 "set the number of frames to record", "number" },
1935 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1936 "force codec tag/fourcc", "fourcc/tag" },
1937 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1938 "use fixed quality scale (VBR)", "q" },
1939 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1940 "use fixed quality scale (VBR)", "q" },
1941 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1942 "set stream filterchain", "filter_list" },
1943 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1944 "create a complex filtergraph", "graph_description" },
1945 { "stats", OPT_BOOL, { &print_stats },
1946 "print progress report during encoding", },
1947 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
1948 "add an attachment to the output file", "filename" },
1949 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1950 "extract an attachment into a file", "filename" },
1951 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1952 "set CPU flags mask", "mask" },
1955 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
1956 "set the number of video frames to record", "number" },
1957 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1958 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1959 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1960 "set frame size (WxH or abbreviation)", "size" },
1961 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1962 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1963 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1964 "set pixel format", "format" },
1965 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1967 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1968 "discard threshold", "n" },
1969 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1970 "rate control override for specific intervals", "override" },
1971 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
1972 "force video codec ('copy' to copy stream)", "codec" },
1973 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
1974 "select the pass number (1 or 2)", "n" },
1975 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
1976 "select two pass log file name prefix", "prefix" },
1977 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1978 "this option is deprecated, use the yadif filter instead" },
1979 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1980 "dump video coding statistics to file" },
1981 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1982 "dump video coding statistics to file", "file" },
1983 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
1984 "video filters", "filter list" },
1985 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1986 "specify intra matrix coeffs", "matrix" },
1987 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1988 "specify inter matrix coeffs", "matrix" },
1989 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1990 "top=1/bottom=0/auto=-1 field first", "" },
1991 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1992 "intra_dc_precision", "precision" },
1993 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
1994 "force video tag/fourcc", "fourcc/tag" },
1995 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1996 "show QP histogram" },
1997 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
1998 "force the selected framerate, disable the best supported framerate selection" },
1999 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2000 "set the value of an outfile streamid", "streamIndex:value" },
2001 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2002 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2005 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2006 "set the number of audio frames to record", "number" },
2007 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2008 "set audio quality (codec-specific)", "quality", },
2009 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2010 "set audio sampling rate (in Hz)", "rate" },
2011 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2012 "set number of audio channels", "channels" },
2013 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2015 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2016 "force audio codec ('copy' to copy stream)", "codec" },
2017 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2018 "force audio tag/fourcc", "fourcc/tag" },
2019 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2020 "change audio volume (256=normal)" , "volume" },
2021 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2022 "set sample format", "format" },
2023 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2024 "set channel layout", "layout" },
2025 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2026 "audio filters", "filter list" },
2028 /* subtitle options */
2029 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2030 "disable subtitle" },
2031 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2032 "force subtitle codec ('copy' to copy stream)", "codec" },
2033 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2034 , "force subtitle tag/fourcc", "fourcc/tag" },
2037 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2040 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2041 "set the maximum demux-decode delay", "seconds" },
2042 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2043 "set the initial demux-decode delay", "seconds" },
2045 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2046 "A comma-separated list of bitstream filters", "bitstream_filters" },
2048 /* data codec support */
2049 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2050 "force data codec ('copy' to copy stream)", "codec" },
2052 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2053 "generic catch all option", "" },