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;
759 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
763 if (oc->nb_streams - 1 < o->nb_streamid_map)
764 st->id = o->streamid_map[oc->nb_streams - 1];
766 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
767 nb_output_streams + 1);
768 if (!(ost = av_mallocz(sizeof(*ost))))
770 output_streams[nb_output_streams - 1] = ost;
772 ost->file_index = nb_output_files;
775 st->codec->codec_type = type;
776 choose_encoder(o, oc, ost);
778 AVIOContext *s = NULL;
779 char *buf = NULL, *arg = NULL, *preset = NULL;
781 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
783 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
784 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
787 if (!buf[0] || buf[0] == '#') {
791 if (!(arg = strchr(buf, '='))) {
792 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
796 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
798 } while (!s->eof_reached);
802 av_log(NULL, AV_LOG_FATAL,
803 "Preset %s specified for stream %d:%d, but could not be opened.\n",
804 preset, ost->file_index, ost->index);
809 avcodec_get_context_defaults3(st->codec, ost->enc);
810 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
812 ost->max_frames = INT64_MAX;
813 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
815 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
817 if (next = strchr(bsf, ','))
819 if (!(bsfc = av_bitstream_filter_init(bsf))) {
820 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
824 bsfc_prev->next = bsfc;
826 ost->bitstream_filters = bsfc;
832 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
834 uint32_t tag = strtol(codec_tag, &next, 0);
836 tag = AV_RL32(codec_tag);
837 st->codec->codec_tag = tag;
840 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
842 st->codec->flags |= CODEC_FLAG_QSCALE;
843 st->codec->global_quality = FF_QP2LAMBDA * qscale;
846 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
847 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
849 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
851 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
866 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
877 AVCodecContext *video_enc;
879 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
881 video_enc = st->codec;
883 if (!ost->stream_copy) {
884 const char *p = NULL;
885 char *frame_rate = NULL, *frame_size = NULL;
886 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
887 char *intra_matrix = NULL, *inter_matrix = NULL;
888 const char *filters = "null";
892 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
893 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
894 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
898 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
899 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
900 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
904 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
905 if (frame_aspect_ratio)
906 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
908 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
909 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
910 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
913 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
915 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
917 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
918 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
921 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
923 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
925 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
926 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
929 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
932 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
933 for (i = 0; p; i++) {
935 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
937 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
940 video_enc->rc_override =
941 av_realloc(video_enc->rc_override,
942 sizeof(RcOverride) * (i + 1));
943 video_enc->rc_override[i].start_frame = start;
944 video_enc->rc_override[i].end_frame = end;
946 video_enc->rc_override[i].qscale = q;
947 video_enc->rc_override[i].quality_factor = 1.0;
950 video_enc->rc_override[i].qscale = 0;
951 video_enc->rc_override[i].quality_factor = -q/100.0;
956 video_enc->rc_override_count = i;
957 if (!video_enc->rc_initial_buffer_occupancy)
958 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
959 video_enc->intra_dc_precision = intra_dc_precision - 8;
962 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
965 video_enc->flags |= CODEC_FLAG_PASS1;
967 video_enc->flags |= CODEC_FLAG_PASS2;
971 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
972 if (ost->logfile_prefix &&
973 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
976 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
977 if (ost->forced_keyframes)
978 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
980 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
982 ost->top_field_first = -1;
983 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
985 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
986 ost->avfilter = av_strdup(filters);
988 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
994 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
998 AVCodecContext *audio_enc;
1000 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1003 audio_enc = st->codec;
1004 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1006 if (!ost->stream_copy) {
1007 char *sample_fmt = NULL;
1008 const char *filters = "anull";
1010 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1012 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1014 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1015 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1019 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1021 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1022 ost->avfilter = av_strdup(filters);
1028 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1032 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1033 if (!ost->stream_copy) {
1034 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1041 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1043 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1044 ost->stream_copy = 1;
1048 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1052 AVCodecContext *subtitle_enc;
1054 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1056 subtitle_enc = st->codec;
1058 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1063 /* arg format is "output-stream-index:streamid-value". */
1064 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1066 OptionsContext *o = optctx;
1071 av_strlcpy(idx_str, arg, sizeof(idx_str));
1072 p = strchr(idx_str, ':');
1074 av_log(NULL, AV_LOG_FATAL,
1075 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1080 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1081 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1082 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1086 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1088 AVFormatContext *is = ifile->ctx;
1089 AVFormatContext *os = ofile->ctx;
1093 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1095 return AVERROR(ENOMEM);
1098 for (i = 0; i < is->nb_chapters; i++) {
1099 AVChapter *in_ch = is->chapters[i], *out_ch;
1100 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1101 AV_TIME_BASE_Q, in_ch->time_base);
1102 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1103 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1106 if (in_ch->end < ts_off)
1108 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1111 out_ch = av_mallocz(sizeof(AVChapter));
1113 return AVERROR(ENOMEM);
1115 out_ch->id = in_ch->id;
1116 out_ch->time_base = in_ch->time_base;
1117 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1118 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1121 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1123 os->chapters[os->nb_chapters++] = out_ch;
1128 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1129 AVFormatContext *oc)
1133 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1134 ofilter->out_tmp->pad_idx)) {
1135 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1136 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1138 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1143 ost->source_index = -1;
1144 ost->filter = ofilter;
1148 if (ost->stream_copy) {
1149 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1150 "which is fed from a complex filtergraph. Filtering and streamcopy "
1151 "cannot be used together.\n", ost->file_index, ost->index);
1155 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1156 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1159 avfilter_inout_free(&ofilter->out_tmp);
1162 static int configure_complex_filters(void)
1166 for (i = 0; i < nb_filtergraphs; i++)
1167 if (!filtergraphs[i]->graph &&
1168 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1173 void opt_output_file(void *optctx, const char *filename)
1175 OptionsContext *o = optctx;
1176 AVFormatContext *oc;
1178 AVOutputFormat *file_oformat;
1182 if (configure_complex_filters() < 0) {
1183 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1187 if (!strcmp(filename, "-"))
1190 oc = avformat_alloc_context();
1192 print_error(filename, AVERROR(ENOMEM));
1197 file_oformat = av_guess_format(o->format, NULL, NULL);
1198 if (!file_oformat) {
1199 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1203 file_oformat = av_guess_format(NULL, filename, NULL);
1204 if (!file_oformat) {
1205 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1211 oc->oformat = file_oformat;
1212 oc->interrupt_callback = int_cb;
1213 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1215 /* create streams for all unlabeled output pads */
1216 for (i = 0; i < nb_filtergraphs; i++) {
1217 FilterGraph *fg = filtergraphs[i];
1218 for (j = 0; j < fg->nb_outputs; j++) {
1219 OutputFilter *ofilter = fg->outputs[j];
1221 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1224 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1225 ofilter->out_tmp->pad_idx)) {
1226 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1227 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1228 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1230 init_output_filter(ofilter, o, oc);
1234 if (!o->nb_stream_maps) {
1235 /* pick the "best" stream of each type */
1236 #define NEW_STREAM(type, index)\
1238 ost = new_ ## type ## _stream(o, oc);\
1239 ost->source_index = index;\
1240 ost->sync_ist = input_streams[index];\
1241 input_streams[index]->discard = 0;\
1242 input_streams[index]->st->discard = AVDISCARD_NONE;\
1245 /* video: highest resolution */
1246 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1247 int area = 0, idx = -1;
1248 for (i = 0; i < nb_input_streams; i++) {
1249 ist = input_streams[i];
1250 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1251 ist->st->codec->width * ist->st->codec->height > area) {
1252 area = ist->st->codec->width * ist->st->codec->height;
1256 NEW_STREAM(video, idx);
1259 /* audio: most channels */
1260 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1261 int channels = 0, idx = -1;
1262 for (i = 0; i < nb_input_streams; i++) {
1263 ist = input_streams[i];
1264 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1265 ist->st->codec->channels > channels) {
1266 channels = ist->st->codec->channels;
1270 NEW_STREAM(audio, idx);
1273 /* subtitles: pick first */
1274 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1275 for (i = 0; i < nb_input_streams; i++)
1276 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1277 NEW_STREAM(subtitle, i);
1281 /* do something with data? */
1283 for (i = 0; i < o->nb_stream_maps; i++) {
1284 StreamMap *map = &o->stream_maps[i];
1289 if (map->linklabel) {
1291 OutputFilter *ofilter = NULL;
1294 for (j = 0; j < nb_filtergraphs; j++) {
1295 fg = filtergraphs[j];
1296 for (k = 0; k < fg->nb_outputs; k++) {
1297 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1298 if (out && !strcmp(out->name, map->linklabel)) {
1299 ofilter = fg->outputs[k];
1306 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1307 "in any defined filter graph.\n", map->linklabel);
1310 init_output_filter(ofilter, o, oc);
1312 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1313 switch (ist->st->codec->codec_type) {
1314 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1315 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1316 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1317 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1318 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1320 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1321 map->file_index, map->stream_index);
1325 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1326 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1327 map->sync_stream_index];
1329 ist->st->discard = AVDISCARD_NONE;
1334 /* handle attached files */
1335 for (i = 0; i < o->nb_attachments; i++) {
1337 uint8_t *attachment;
1341 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1342 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1346 if ((len = avio_size(pb)) <= 0) {
1347 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1351 if (!(attachment = av_malloc(len))) {
1352 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1356 avio_read(pb, attachment, len);
1358 ost = new_attachment_stream(o, oc);
1359 ost->stream_copy = 0;
1360 ost->source_index = -1;
1361 ost->attachment_filename = o->attachments[i];
1362 ost->st->codec->extradata = attachment;
1363 ost->st->codec->extradata_size = len;
1365 p = strrchr(o->attachments[i], '/');
1366 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1370 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1371 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1374 output_files[nb_output_files - 1]->ctx = oc;
1375 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1376 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1377 if (o->recording_time != INT64_MAX)
1378 oc->duration = o->recording_time;
1379 output_files[nb_output_files - 1]->start_time = o->start_time;
1380 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1381 output_files[nb_output_files - 1]->shortest = o->shortest;
1382 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1384 /* check filename in case of an image number is expected */
1385 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1386 if (!av_filename_number_test(oc->filename)) {
1387 print_error(oc->filename, AVERROR(EINVAL));
1392 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1393 /* test if it already exists to avoid losing precious files */
1394 assert_file_overwrite(filename);
1397 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1398 &oc->interrupt_callback,
1399 &output_files[nb_output_files - 1]->opts)) < 0) {
1400 print_error(filename, err);
1405 if (o->mux_preload) {
1407 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1408 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1410 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1411 oc->flags |= AVFMT_FLAG_NONBLOCK;
1414 for (i = 0; i < o->nb_metadata_map; i++) {
1416 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1418 if (in_file_index >= nb_input_files) {
1419 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1422 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1423 in_file_index >= 0 ?
1424 input_files[in_file_index]->ctx : NULL, o);
1428 if (o->chapters_input_file >= nb_input_files) {
1429 if (o->chapters_input_file == INT_MAX) {
1430 /* copy chapters from the first input file that has them*/
1431 o->chapters_input_file = -1;
1432 for (i = 0; i < nb_input_files; i++)
1433 if (input_files[i]->ctx->nb_chapters) {
1434 o->chapters_input_file = i;
1438 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1439 o->chapters_input_file);
1443 if (o->chapters_input_file >= 0)
1444 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1445 !o->metadata_chapters_manual);
1447 /* copy global metadata by default */
1448 if (!o->metadata_global_manual && nb_input_files)
1449 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1450 AV_DICT_DONT_OVERWRITE);
1451 if (!o->metadata_streams_manual)
1452 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1454 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1456 ist = input_streams[output_streams[i]->source_index];
1457 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1460 /* process manually set metadata */
1461 for (i = 0; i < o->nb_metadata; i++) {
1464 const char *stream_spec;
1465 int index = 0, j, ret;
1467 val = strchr(o->metadata[i].u.str, '=');
1469 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1470 o->metadata[i].u.str);
1475 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1477 for (j = 0; j < oc->nb_streams; j++) {
1478 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1479 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1490 if (index < 0 || index >= oc->nb_chapters) {
1491 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1494 m = &oc->chapters[index]->metadata;
1497 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1500 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1507 static int opt_target(void *optctx, const char *opt, const char *arg)
1509 OptionsContext *o = optctx;
1510 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1511 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1513 if (!strncmp(arg, "pal-", 4)) {
1516 } else if (!strncmp(arg, "ntsc-", 5)) {
1519 } else if (!strncmp(arg, "film-", 5)) {
1523 /* Try to determine PAL/NTSC by peeking in the input files */
1524 if (nb_input_files) {
1526 for (j = 0; j < nb_input_files; j++) {
1527 for (i = 0; i < input_files[j]->nb_streams; i++) {
1528 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1529 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1531 fr = c->time_base.den * 1000 / c->time_base.num;
1535 } else if ((fr == 29970) || (fr == 23976)) {
1540 if (norm != UNKNOWN)
1544 if (norm != UNKNOWN)
1545 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1548 if (norm == UNKNOWN) {
1549 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1550 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1551 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1555 if (!strcmp(arg, "vcd")) {
1556 opt_video_codec(o, "c:v", "mpeg1video");
1557 opt_audio_codec(o, "c:a", "mp2");
1558 parse_option(o, "f", "vcd", options);
1560 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1561 parse_option(o, "r", frame_rates[norm], options);
1562 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1564 opt_default(NULL, "b", "1150000");
1565 opt_default(NULL, "maxrate", "1150000");
1566 opt_default(NULL, "minrate", "1150000");
1567 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1569 opt_default(NULL, "b:a", "224000");
1570 parse_option(o, "ar", "44100", options);
1571 parse_option(o, "ac", "2", options);
1573 opt_default(NULL, "packetsize", "2324");
1574 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1576 /* We have to offset the PTS, so that it is consistent with the SCR.
1577 SCR starts at 36000, but the first two packs contain only padding
1578 and the first pack from the other stream, respectively, may also have
1579 been written before.
1580 So the real data starts at SCR 36000+3*1200. */
1581 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1582 } else if (!strcmp(arg, "svcd")) {
1584 opt_video_codec(o, "c:v", "mpeg2video");
1585 opt_audio_codec(o, "c:a", "mp2");
1586 parse_option(o, "f", "svcd", options);
1588 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1589 parse_option(o, "r", frame_rates[norm], options);
1590 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1592 opt_default(NULL, "b", "2040000");
1593 opt_default(NULL, "maxrate", "2516000");
1594 opt_default(NULL, "minrate", "0"); // 1145000;
1595 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1596 opt_default(NULL, "flags", "+scan_offset");
1599 opt_default(NULL, "b:a", "224000");
1600 parse_option(o, "ar", "44100", options);
1602 opt_default(NULL, "packetsize", "2324");
1604 } else if (!strcmp(arg, "dvd")) {
1606 opt_video_codec(o, "c:v", "mpeg2video");
1607 opt_audio_codec(o, "c:a", "ac3");
1608 parse_option(o, "f", "dvd", options);
1610 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1611 parse_option(o, "r", frame_rates[norm], options);
1612 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1614 opt_default(NULL, "b", "6000000");
1615 opt_default(NULL, "maxrate", "9000000");
1616 opt_default(NULL, "minrate", "0"); // 1500000;
1617 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1619 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1620 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1622 opt_default(NULL, "b:a", "448000");
1623 parse_option(o, "ar", "48000", options);
1625 } else if (!strncmp(arg, "dv", 2)) {
1627 parse_option(o, "f", "dv", options);
1629 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1630 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1631 norm == PAL ? "yuv420p" : "yuv411p", options);
1632 parse_option(o, "r", frame_rates[norm], options);
1634 parse_option(o, "ar", "48000", options);
1635 parse_option(o, "ac", "2", options);
1638 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1639 return AVERROR(EINVAL);
1644 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1646 av_free (vstats_filename);
1647 vstats_filename = av_strdup (arg);
1651 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1654 time_t today2 = time(NULL);
1655 struct tm *today = localtime(&today2);
1657 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1659 return opt_vstats_file(NULL, opt, filename);
1662 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1664 OptionsContext *o = optctx;
1665 return parse_option(o, "frames:v", arg, options);
1668 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1670 OptionsContext *o = optctx;
1671 return parse_option(o, "frames:a", arg, options);
1674 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1676 OptionsContext *o = optctx;
1677 return parse_option(o, "frames:d", arg, options);
1680 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1682 OptionsContext *o = optctx;
1683 return parse_option(o, "tag:v", arg, options);
1686 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1688 OptionsContext *o = optctx;
1689 return parse_option(o, "tag:a", arg, options);
1692 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1694 OptionsContext *o = optctx;
1695 return parse_option(o, "tag:s", arg, options);
1698 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1700 OptionsContext *o = optctx;
1701 return parse_option(o, "filter:v", arg, options);
1704 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1706 OptionsContext *o = optctx;
1707 return parse_option(o, "filter:a", arg, options);
1710 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1712 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1713 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1714 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1716 if (video_sync_method == VSYNC_AUTO)
1717 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1721 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1723 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1728 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1730 int flags = av_parse_cpu_flags(arg);
1735 av_set_cpu_flags_mask(flags);
1739 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1741 OptionsContext *o = optctx;
1742 char layout_str[32];
1745 int ret, channels, ac_str_size;
1748 layout = av_get_channel_layout(arg);
1750 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1751 return AVERROR(EINVAL);
1753 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1754 ret = opt_default(NULL, opt, layout_str);
1758 /* set 'ac' option based on channel layout */
1759 channels = av_get_channel_layout_nb_channels(layout);
1760 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1761 stream_str = strchr(opt, ':');
1762 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1763 ac_str = av_mallocz(ac_str_size);
1765 return AVERROR(ENOMEM);
1766 av_strlcpy(ac_str, "ac", 3);
1768 av_strlcat(ac_str, stream_str, ac_str_size);
1769 ret = parse_option(o, ac_str, layout_str, options);
1775 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1777 OptionsContext *o = optctx;
1778 return parse_option(o, "q:a", arg, options);
1781 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1783 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1784 &nb_filtergraphs, nb_filtergraphs + 1);
1785 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1786 return AVERROR(ENOMEM);
1787 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1788 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1792 void show_help_default(const char *opt, const char *arg)
1794 /* per-file options have at least one of those set */
1795 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1796 int show_advanced = 0, show_avoptions = 0;
1799 if (!strcmp(opt, "long"))
1801 else if (!strcmp(opt, "full"))
1802 show_advanced = show_avoptions = 1;
1804 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1809 printf("Getting help:\n"
1810 " -h -- print basic options\n"
1811 " -h long -- print more options\n"
1812 " -h full -- print all options (including all format and codec specific options, very long)\n"
1813 " See man %s for detailed description of the options.\n"
1814 "\n", program_name);
1816 show_help_options(options, "Print help / information / capabilities:",
1819 show_help_options(options, "Global options (affect whole program "
1820 "instead of just one file:",
1821 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1823 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1824 per_file | OPT_EXIT, 0);
1826 show_help_options(options, "Per-file main options:", 0,
1827 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1828 OPT_EXIT, per_file);
1830 show_help_options(options, "Advanced per-file options:",
1831 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1833 show_help_options(options, "Video options:",
1834 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1836 show_help_options(options, "Advanced Video options:",
1837 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1839 show_help_options(options, "Audio options:",
1840 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1842 show_help_options(options, "Advanced Audio options:",
1843 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1844 show_help_options(options, "Subtitle options:",
1845 OPT_SUBTITLE, 0, 0);
1848 if (show_avoptions) {
1849 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1850 show_help_children(avcodec_get_class(), flags);
1851 show_help_children(avformat_get_class(), flags);
1852 show_help_children(sws_get_class(), flags);
1856 void show_usage(void)
1858 printf("Hyper fast Audio and Video encoder\n");
1859 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1864 #define OFFSET(x) offsetof(OptionsContext, x)
1865 const OptionDef options[] = {
1867 #include "cmdutils_common_opts.h"
1868 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1869 "force format", "fmt" },
1870 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
1871 "input file name", "filename" },
1872 { "y", OPT_BOOL, { &file_overwrite },
1873 "overwrite output files" },
1874 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1875 "codec name", "codec" },
1876 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1877 "codec name", "codec" },
1878 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1879 "preset name", "preset" },
1880 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1881 "set input stream mapping",
1882 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1883 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1884 "set metadata information of outfile from infile",
1885 "outfile[,metadata]:infile[,metadata]" },
1886 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1887 "set chapters mapping", "input_file_index" },
1888 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1889 "record or transcode \"duration\" seconds of audio/video",
1891 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1892 "set the limit file size in bytes", "limit_size" },
1893 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1894 "set the start time offset", "time_off" },
1895 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1896 "set the input ts offset", "time_off" },
1897 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1898 "set the input ts scale", "scale" },
1899 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1900 "add metadata", "string=string" },
1901 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1902 "set the number of data frames to record", "number" },
1903 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1904 "add timings for benchmarking" },
1905 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1906 "set max runtime in seconds", "limit" },
1907 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1908 "dump each input packet" },
1909 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1910 "when dumping packets, also dump the payload" },
1911 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1912 "read input at native frame rate", "" },
1913 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1914 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1915 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1916 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
1917 "video sync method", "" },
1918 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
1919 "audio sync method", "" },
1920 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
1921 "audio drift threshold", "threshold" },
1922 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
1923 "copy timestamps" },
1924 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
1925 "copy input stream time base when stream copying" },
1926 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
1927 "finish encoding within shortest input" },
1928 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
1929 "timestamp discontinuity delta threshold", "threshold" },
1930 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
1931 "exit on error", "error" },
1932 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
1933 "copy initial non-keyframes" },
1934 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
1935 "set the number of frames to record", "number" },
1936 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
1937 "force codec tag/fourcc", "fourcc/tag" },
1938 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1939 "use fixed quality scale (VBR)", "q" },
1940 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
1941 "use fixed quality scale (VBR)", "q" },
1942 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
1943 "set stream filterchain", "filter_list" },
1944 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
1945 "create a complex filtergraph", "graph_description" },
1946 { "stats", OPT_BOOL, { &print_stats },
1947 "print progress report during encoding", },
1948 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
1949 "add an attachment to the output file", "filename" },
1950 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
1951 "extract an attachment into a file", "filename" },
1952 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
1953 "set CPU flags mask", "mask" },
1956 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
1957 "set the number of video frames to record", "number" },
1958 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
1959 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
1960 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
1961 "set frame size (WxH or abbreviation)", "size" },
1962 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
1963 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1964 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
1965 "set pixel format", "format" },
1966 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
1968 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
1969 "discard threshold", "n" },
1970 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
1971 "rate control override for specific intervals", "override" },
1972 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
1973 "force video codec ('copy' to copy stream)", "codec" },
1974 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
1975 "select the pass number (1 or 2)", "n" },
1976 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
1977 "select two pass log file name prefix", "prefix" },
1978 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
1979 "this option is deprecated, use the yadif filter instead" },
1980 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
1981 "dump video coding statistics to file" },
1982 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
1983 "dump video coding statistics to file", "file" },
1984 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
1985 "video filters", "filter list" },
1986 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1987 "specify intra matrix coeffs", "matrix" },
1988 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1989 "specify inter matrix coeffs", "matrix" },
1990 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
1991 "top=1/bottom=0/auto=-1 field first", "" },
1992 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
1993 "intra_dc_precision", "precision" },
1994 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
1995 "force video tag/fourcc", "fourcc/tag" },
1996 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
1997 "show QP histogram" },
1998 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
1999 "force the selected framerate, disable the best supported framerate selection" },
2000 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2001 "set the value of an outfile streamid", "streamIndex:value" },
2002 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2003 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2006 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2007 "set the number of audio frames to record", "number" },
2008 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2009 "set audio quality (codec-specific)", "quality", },
2010 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2011 "set audio sampling rate (in Hz)", "rate" },
2012 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2013 "set number of audio channels", "channels" },
2014 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2016 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2017 "force audio codec ('copy' to copy stream)", "codec" },
2018 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2019 "force audio tag/fourcc", "fourcc/tag" },
2020 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2021 "change audio volume (256=normal)" , "volume" },
2022 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2023 "set sample format", "format" },
2024 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2025 "set channel layout", "layout" },
2026 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2027 "audio filters", "filter list" },
2029 /* subtitle options */
2030 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2031 "disable subtitle" },
2032 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2033 "force subtitle codec ('copy' to copy stream)", "codec" },
2034 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2035 , "force subtitle tag/fourcc", "fourcc/tag" },
2038 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2041 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2042 "set the maximum demux-decode delay", "seconds" },
2043 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2044 "set the initial demux-decode delay", "seconds" },
2046 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2047 "A comma-separated list of bitstream filters", "bitstream_filters" },
2049 /* data codec support */
2050 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2051 "force data codec ('copy' to copy stream)", "codec" },
2053 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2054 "generic catch all option", "" },