2 * avconv option parsing
4 * This file is part of Libav.
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 char *vstats_filename;
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold = 10;
62 int audio_volume = 256;
63 int audio_sync_method = 0;
64 int video_sync_method = VSYNC_AUTO;
65 int do_deinterlace = 0;
71 int exit_on_error = 0;
75 static int file_overwrite = 0;
76 static int video_discard = 0;
77 static int intra_dc_precision = 8;
78 static int using_stdin = 0;
79 static int input_sync;
81 static void uninit_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);
112 static void init_options(OptionsContext *o)
114 memset(o, 0, sizeof(*o));
116 o->mux_max_delay = 0.7;
117 o->recording_time = INT64_MAX;
118 o->limit_filesize = UINT64_MAX;
119 o->chapters_input_file = INT_MAX;
122 static double parse_frame_aspect_ratio(const char *arg)
129 p = strchr(arg, ':');
131 x = strtol(arg, &end, 10);
133 y = strtol(end + 1, &end, 10);
135 ar = (double)x / (double)y;
137 ar = strtod(arg, NULL);
140 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
146 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
148 OptionsContext *o = optctx;
149 return parse_option(o, "codec:a", arg, options);
152 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
154 OptionsContext *o = optctx;
155 return parse_option(o, "codec:v", arg, options);
158 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
160 OptionsContext *o = optctx;
161 return parse_option(o, "codec:s", arg, options);
164 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
166 OptionsContext *o = optctx;
167 return parse_option(o, "codec:d", arg, options);
170 static int opt_map(void *optctx, const char *opt, const char *arg)
172 OptionsContext *o = optctx;
174 int i, negative = 0, file_idx;
175 int sync_file_idx = -1, sync_stream_idx;
183 map = av_strdup(arg);
185 /* parse sync stream first, just pick first matching stream */
186 if (sync = strchr(map, ',')) {
188 sync_file_idx = strtol(sync + 1, &sync, 0);
189 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
190 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
195 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
196 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
197 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
201 if (i == input_files[sync_file_idx]->nb_streams) {
202 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
203 "match any streams.\n", arg);
210 /* this mapping refers to lavfi output */
211 const char *c = map + 1;
212 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
213 m = &o->stream_maps[o->nb_stream_maps - 1];
214 m->linklabel = av_get_token(&c, "]");
216 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
220 file_idx = strtol(map, &p, 0);
221 if (file_idx >= nb_input_files || file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
226 /* disable some already defined maps */
227 for (i = 0; i < o->nb_stream_maps; i++) {
228 m = &o->stream_maps[i];
229 if (file_idx == m->file_index &&
230 check_stream_specifier(input_files[m->file_index]->ctx,
231 input_files[m->file_index]->ctx->streams[m->stream_index],
232 *p == ':' ? p + 1 : p) > 0)
236 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
237 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
238 *p == ':' ? p + 1 : p) <= 0)
240 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
241 m = &o->stream_maps[o->nb_stream_maps - 1];
243 m->file_index = file_idx;
246 if (sync_file_idx >= 0) {
247 m->sync_file_index = sync_file_idx;
248 m->sync_stream_index = sync_stream_idx;
250 m->sync_file_index = file_idx;
251 m->sync_stream_index = i;
257 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
265 static int opt_attach(void *optctx, const char *opt, const char *arg)
267 OptionsContext *o = optctx;
268 GROW_ARRAY(o->attachments, o->nb_attachments);
269 o->attachments[o->nb_attachments - 1] = arg;
274 * Parse a metadata specifier passed as 'arg' parameter.
275 * @param arg metadata string to parse
276 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
277 * @param index for type c/p, chapter/program index is written here
278 * @param stream_spec for type s, the stream specifier is written here
280 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
288 if (*(++arg) && *arg != ':') {
289 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
292 *stream_spec = *arg == ':' ? arg + 1 : "";
297 *index = strtol(++arg, NULL, 0);
300 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
307 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
309 AVDictionary **meta_in = NULL;
310 AVDictionary **meta_out;
312 char type_in, type_out;
313 const char *istream_spec = NULL, *ostream_spec = NULL;
314 int idx_in = 0, idx_out = 0;
316 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
317 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
319 if (type_in == 'g' || type_out == 'g')
320 o->metadata_global_manual = 1;
321 if (type_in == 's' || type_out == 's')
322 o->metadata_streams_manual = 1;
323 if (type_in == 'c' || type_out == 'c')
324 o->metadata_chapters_manual = 1;
326 /* ic is NULL when just disabling automatic mappings */
330 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
331 if ((index) < 0 || (index) >= (nb_elems)) {\
332 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
337 #define SET_DICT(type, meta, context, index)\
340 meta = &context->metadata;\
343 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
344 meta = &context->chapters[index]->metadata;\
347 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
348 meta = &context->programs[index]->metadata;\
351 break; /* handled separately below */ \
352 default: av_assert0(0);\
355 SET_DICT(type_in, meta_in, ic, idx_in);
356 SET_DICT(type_out, meta_out, oc, idx_out);
358 /* for input streams choose first matching stream */
359 if (type_in == 's') {
360 for (i = 0; i < ic->nb_streams; i++) {
361 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
362 meta_in = &ic->streams[i]->metadata;
368 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
373 if (type_out == 's') {
374 for (i = 0; i < oc->nb_streams; i++) {
375 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
376 meta_out = &oc->streams[i]->metadata;
377 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
382 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
389 const AVCodecDescriptor *desc;
390 const char *codec_string = encoder ? "encoder" : "decoder";
394 avcodec_find_encoder_by_name(name) :
395 avcodec_find_decoder_by_name(name);
397 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
398 codec = encoder ? avcodec_find_encoder(desc->id) :
399 avcodec_find_decoder(desc->id);
401 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
402 codec_string, codec->name, desc->name);
406 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
409 if (codec->type != type) {
410 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
416 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
418 char *codec_name = NULL;
420 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
422 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
423 st->codec->codec_id = codec->id;
426 return avcodec_find_decoder(st->codec->codec_id);
429 /* Add all the streams from the given input file to the global
430 * list of input streams. */
431 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
435 for (i = 0; i < ic->nb_streams; i++) {
436 AVStream *st = ic->streams[i];
437 AVCodecContext *dec = st->codec;
438 InputStream *ist = av_mallocz(sizeof(*ist));
439 char *framerate = NULL;
444 GROW_ARRAY(input_streams, nb_input_streams);
445 input_streams[nb_input_streams - 1] = ist;
448 ist->file_index = nb_input_files;
450 st->discard = AVDISCARD_ALL;
453 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
455 ist->dec = choose_decoder(o, ic, st);
456 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
458 switch (dec->codec_type) {
459 case AVMEDIA_TYPE_VIDEO:
460 ist->resample_height = dec->height;
461 ist->resample_width = dec->width;
462 ist->resample_pix_fmt = dec->pix_fmt;
464 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
465 if (framerate && av_parse_video_rate(&ist->framerate,
467 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
473 case AVMEDIA_TYPE_AUDIO:
474 guess_input_channel_layout(ist);
476 ist->resample_sample_fmt = dec->sample_fmt;
477 ist->resample_sample_rate = dec->sample_rate;
478 ist->resample_channels = dec->channels;
479 ist->resample_channel_layout = dec->channel_layout;
482 case AVMEDIA_TYPE_DATA:
483 case AVMEDIA_TYPE_SUBTITLE:
484 case AVMEDIA_TYPE_ATTACHMENT:
485 case AVMEDIA_TYPE_UNKNOWN:
493 static void assert_file_overwrite(const char *filename)
495 if (!file_overwrite &&
496 (strchr(filename, ':') == NULL || filename[1] == ':' ||
497 av_strstart(filename, "file:", NULL))) {
498 if (avio_check(filename, 0) == 0) {
500 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
503 fprintf(stderr, "Not overwriting - exiting\n");
508 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
515 static void dump_attachment(AVStream *st, const char *filename)
518 AVIOContext *out = NULL;
519 AVDictionaryEntry *e;
521 if (!st->codec->extradata_size) {
522 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
523 nb_input_files - 1, st->index);
526 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
529 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
530 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
534 assert_file_overwrite(filename);
536 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
537 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
542 avio_write(out, st->codec->extradata, st->codec->extradata_size);
547 static int open_input_file(OptionsContext *o, const char *filename)
551 AVInputFormat *file_iformat = NULL;
556 int orig_nb_streams; // number of streams before avformat_find_stream_info
559 if (!(file_iformat = av_find_input_format(o->format))) {
560 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
565 if (!strcmp(filename, "-"))
568 using_stdin |= !strncmp(filename, "pipe:", 5) ||
569 !strcmp(filename, "/dev/stdin");
571 /* get default parameters from command line */
572 ic = avformat_alloc_context();
574 print_error(filename, AVERROR(ENOMEM));
577 if (o->nb_audio_sample_rate) {
578 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
579 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
581 if (o->nb_audio_channels) {
582 /* because we set audio_channels based on both the "ac" and
583 * "channel_layout" options, we need to check that the specified
584 * demuxer actually has the "channels" option before setting it */
585 if (file_iformat && file_iformat->priv_class &&
586 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
587 AV_OPT_SEARCH_FAKE_OBJ)) {
588 snprintf(buf, sizeof(buf), "%d",
589 o->audio_channels[o->nb_audio_channels - 1].u.i);
590 av_dict_set(&o->g->format_opts, "channels", buf, 0);
593 if (o->nb_frame_rates) {
594 /* set the format-level framerate option;
595 * this is important for video grabbers, e.g. x11 */
596 if (file_iformat && file_iformat->priv_class &&
597 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
598 AV_OPT_SEARCH_FAKE_OBJ)) {
599 av_dict_set(&o->g->format_opts, "framerate",
600 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
603 if (o->nb_frame_sizes) {
604 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
606 if (o->nb_frame_pix_fmts)
607 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
609 ic->flags |= AVFMT_FLAG_NONBLOCK;
610 ic->interrupt_callback = int_cb;
612 /* open the input file with generic libav function */
613 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
615 print_error(filename, err);
618 assert_avoptions(o->g->format_opts);
620 /* apply forced codec ids */
621 for (i = 0; i < ic->nb_streams; i++)
622 choose_decoder(o, ic, ic->streams[i]);
624 /* Set AVCodecContext options for avformat_find_stream_info */
625 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
626 orig_nb_streams = ic->nb_streams;
628 /* If not enough info to get the stream parameters, we decode the
629 first frames to get it. (used in mpeg case for example) */
630 ret = avformat_find_stream_info(ic, opts);
632 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
633 avformat_close_input(&ic);
637 timestamp = o->start_time;
638 /* add the stream start time */
639 if (ic->start_time != AV_NOPTS_VALUE)
640 timestamp += ic->start_time;
642 /* if seeking requested, we execute it */
643 if (o->start_time != 0) {
644 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
646 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
647 filename, (double)timestamp / AV_TIME_BASE);
651 /* update the current parameters so that they match the one of the input stream */
652 add_input_streams(o, ic);
654 /* dump the file content */
655 av_dump_format(ic, nb_input_files, filename, 0);
657 GROW_ARRAY(input_files, nb_input_files);
658 f = av_mallocz(sizeof(*f));
661 input_files[nb_input_files - 1] = f;
664 f->ist_index = nb_input_streams - ic->nb_streams;
665 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
666 f->nb_streams = ic->nb_streams;
667 f->rate_emu = o->rate_emu;
669 for (i = 0; i < o->nb_dump_attachment; i++) {
672 for (j = 0; j < ic->nb_streams; j++) {
673 AVStream *st = ic->streams[j];
675 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
676 dump_attachment(st, o->dump_attachment[i].u.str);
680 for (i = 0; i < orig_nb_streams; i++)
681 av_dict_free(&opts[i]);
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 GROW_ARRAY(output_streams, nb_output_streams);
767 if (!(ost = av_mallocz(sizeof(*ost))))
769 output_streams[nb_output_streams - 1] = ost;
771 ost->file_index = nb_output_files;
774 st->codec->codec_type = type;
775 choose_encoder(o, oc, ost);
777 AVIOContext *s = NULL;
778 char *buf = NULL, *arg = NULL, *preset = NULL;
780 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
782 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
783 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
786 if (!buf[0] || buf[0] == '#') {
790 if (!(arg = strchr(buf, '='))) {
791 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
795 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
797 } while (!s->eof_reached);
801 av_log(NULL, AV_LOG_FATAL,
802 "Preset %s specified for stream %d:%d, but could not be opened.\n",
803 preset, ost->file_index, ost->index);
807 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
810 avcodec_get_context_defaults3(st->codec, ost->enc);
811 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
813 ost->max_frames = INT64_MAX;
814 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
816 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
818 if (next = strchr(bsf, ','))
820 if (!(bsfc = av_bitstream_filter_init(bsf))) {
821 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
825 bsfc_prev->next = bsfc;
827 ost->bitstream_filters = bsfc;
833 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
835 uint32_t tag = strtol(codec_tag, &next, 0);
837 tag = AV_RL32(codec_tag);
838 st->codec->codec_tag = tag;
841 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
843 st->codec->flags |= CODEC_FLAG_QSCALE;
844 st->codec->global_quality = FF_QP2LAMBDA * qscale;
847 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
848 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
850 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
852 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
854 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
859 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
869 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
876 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
880 AVCodecContext *video_enc;
882 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
884 video_enc = st->codec;
886 if (!ost->stream_copy) {
887 const char *p = NULL;
888 char *frame_rate = NULL, *frame_size = NULL;
889 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
890 char *intra_matrix = NULL, *inter_matrix = NULL;
891 const char *filters = "null";
895 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
896 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
897 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
901 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
902 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
903 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
907 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
908 if (frame_aspect_ratio)
909 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
911 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
912 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
913 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
916 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
918 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
920 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
921 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
924 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
926 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
928 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
929 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
932 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
935 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
936 for (i = 0; p; i++) {
938 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
940 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
943 video_enc->rc_override =
944 av_realloc(video_enc->rc_override,
945 sizeof(RcOverride) * (i + 1));
946 video_enc->rc_override[i].start_frame = start;
947 video_enc->rc_override[i].end_frame = end;
949 video_enc->rc_override[i].qscale = q;
950 video_enc->rc_override[i].quality_factor = 1.0;
953 video_enc->rc_override[i].qscale = 0;
954 video_enc->rc_override[i].quality_factor = -q/100.0;
959 video_enc->rc_override_count = i;
960 video_enc->intra_dc_precision = intra_dc_precision - 8;
963 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
966 video_enc->flags |= CODEC_FLAG_PASS1;
968 video_enc->flags |= CODEC_FLAG_PASS2;
972 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
973 if (ost->logfile_prefix &&
974 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
977 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
978 if (ost->forced_keyframes)
979 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
981 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
983 ost->top_field_first = -1;
984 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
986 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
987 ost->avfilter = av_strdup(filters);
989 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
995 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
999 AVCodecContext *audio_enc;
1001 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1004 audio_enc = st->codec;
1005 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1007 if (!ost->stream_copy) {
1008 char *sample_fmt = NULL;
1009 const char *filters = "anull";
1011 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1013 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1015 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1016 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1020 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1022 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1023 ost->avfilter = av_strdup(filters);
1029 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1033 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1034 if (!ost->stream_copy) {
1035 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1042 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1044 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1045 ost->stream_copy = 1;
1049 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1053 AVCodecContext *subtitle_enc;
1055 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1057 subtitle_enc = st->codec;
1059 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1064 /* arg format is "output-stream-index:streamid-value". */
1065 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1067 OptionsContext *o = optctx;
1072 av_strlcpy(idx_str, arg, sizeof(idx_str));
1073 p = strchr(idx_str, ':');
1075 av_log(NULL, AV_LOG_FATAL,
1076 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1081 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1082 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1083 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1087 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1089 AVFormatContext *is = ifile->ctx;
1090 AVFormatContext *os = ofile->ctx;
1094 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1096 return AVERROR(ENOMEM);
1099 for (i = 0; i < is->nb_chapters; i++) {
1100 AVChapter *in_ch = is->chapters[i], *out_ch;
1101 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1102 AV_TIME_BASE_Q, in_ch->time_base);
1103 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1104 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1107 if (in_ch->end < ts_off)
1109 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1112 out_ch = av_mallocz(sizeof(AVChapter));
1114 return AVERROR(ENOMEM);
1116 out_ch->id = in_ch->id;
1117 out_ch->time_base = in_ch->time_base;
1118 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1119 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1122 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1124 os->chapters[os->nb_chapters++] = out_ch;
1129 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1130 AVFormatContext *oc)
1134 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1135 ofilter->out_tmp->pad_idx)) {
1136 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1137 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1139 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1144 ost->source_index = -1;
1145 ost->filter = ofilter;
1149 if (ost->stream_copy) {
1150 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1151 "which is fed from a complex filtergraph. Filtering and streamcopy "
1152 "cannot be used together.\n", ost->file_index, ost->index);
1156 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1157 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1160 avfilter_inout_free(&ofilter->out_tmp);
1163 static int configure_complex_filters(void)
1167 for (i = 0; i < nb_filtergraphs; i++)
1168 if (!filtergraphs[i]->graph &&
1169 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1174 static int open_output_file(OptionsContext *o, const char *filename)
1176 AVFormatContext *oc;
1178 AVOutputFormat *file_oformat;
1183 if (configure_complex_filters() < 0) {
1184 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1188 if (!strcmp(filename, "-"))
1191 oc = avformat_alloc_context();
1193 print_error(filename, AVERROR(ENOMEM));
1198 file_oformat = av_guess_format(o->format, NULL, NULL);
1199 if (!file_oformat) {
1200 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1204 file_oformat = av_guess_format(NULL, filename, NULL);
1205 if (!file_oformat) {
1206 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1212 oc->oformat = file_oformat;
1213 oc->interrupt_callback = int_cb;
1214 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1216 /* create streams for all unlabeled output pads */
1217 for (i = 0; i < nb_filtergraphs; i++) {
1218 FilterGraph *fg = filtergraphs[i];
1219 for (j = 0; j < fg->nb_outputs; j++) {
1220 OutputFilter *ofilter = fg->outputs[j];
1222 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1225 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1226 ofilter->out_tmp->pad_idx)) {
1227 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1228 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1229 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1231 init_output_filter(ofilter, o, oc);
1235 if (!o->nb_stream_maps) {
1236 /* pick the "best" stream of each type */
1237 #define NEW_STREAM(type, index)\
1239 ost = new_ ## type ## _stream(o, oc);\
1240 ost->source_index = index;\
1241 ost->sync_ist = input_streams[index];\
1242 input_streams[index]->discard = 0;\
1243 input_streams[index]->st->discard = AVDISCARD_NONE;\
1246 /* video: highest resolution */
1247 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1248 int area = 0, idx = -1;
1249 for (i = 0; i < nb_input_streams; i++) {
1250 ist = input_streams[i];
1251 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1252 ist->st->codec->width * ist->st->codec->height > area) {
1253 area = ist->st->codec->width * ist->st->codec->height;
1257 NEW_STREAM(video, idx);
1260 /* audio: most channels */
1261 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1262 int channels = 0, idx = -1;
1263 for (i = 0; i < nb_input_streams; i++) {
1264 ist = input_streams[i];
1265 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1266 ist->st->codec->channels > channels) {
1267 channels = ist->st->codec->channels;
1271 NEW_STREAM(audio, idx);
1274 /* subtitles: pick first */
1275 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1276 for (i = 0; i < nb_input_streams; i++)
1277 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1278 NEW_STREAM(subtitle, i);
1282 /* do something with data? */
1284 for (i = 0; i < o->nb_stream_maps; i++) {
1285 StreamMap *map = &o->stream_maps[i];
1290 if (map->linklabel) {
1292 OutputFilter *ofilter = NULL;
1295 for (j = 0; j < nb_filtergraphs; j++) {
1296 fg = filtergraphs[j];
1297 for (k = 0; k < fg->nb_outputs; k++) {
1298 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1299 if (out && !strcmp(out->name, map->linklabel)) {
1300 ofilter = fg->outputs[k];
1307 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1308 "in any defined filter graph.\n", map->linklabel);
1311 init_output_filter(ofilter, o, oc);
1313 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1314 switch (ist->st->codec->codec_type) {
1315 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1316 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1317 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1318 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1319 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1321 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1322 map->file_index, map->stream_index);
1326 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1327 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1328 map->sync_stream_index];
1330 ist->st->discard = AVDISCARD_NONE;
1335 /* handle attached files */
1336 for (i = 0; i < o->nb_attachments; i++) {
1338 uint8_t *attachment;
1342 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1343 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1347 if ((len = avio_size(pb)) <= 0) {
1348 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1352 if (!(attachment = av_malloc(len))) {
1353 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1357 avio_read(pb, attachment, len);
1359 ost = new_attachment_stream(o, oc);
1360 ost->stream_copy = 0;
1361 ost->source_index = -1;
1362 ost->attachment_filename = o->attachments[i];
1363 ost->st->codec->extradata = attachment;
1364 ost->st->codec->extradata_size = len;
1366 p = strrchr(o->attachments[i], '/');
1367 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1371 GROW_ARRAY(output_files, nb_output_files);
1372 of = av_mallocz(sizeof(*of));
1375 output_files[nb_output_files - 1] = of;
1378 of->ost_index = nb_output_streams - oc->nb_streams;
1379 of->recording_time = o->recording_time;
1380 if (o->recording_time != INT64_MAX)
1381 oc->duration = o->recording_time;
1382 of->start_time = o->start_time;
1383 of->limit_filesize = o->limit_filesize;
1384 of->shortest = o->shortest;
1385 av_dict_copy(&of->opts, o->g->format_opts, 0);
1387 /* check filename in case of an image number is expected */
1388 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1389 if (!av_filename_number_test(oc->filename)) {
1390 print_error(oc->filename, AVERROR(EINVAL));
1395 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1396 /* test if it already exists to avoid losing precious files */
1397 assert_file_overwrite(filename);
1400 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1401 &oc->interrupt_callback,
1403 print_error(filename, err);
1408 if (o->mux_preload) {
1410 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1411 av_dict_set(&of->opts, "preload", buf, 0);
1413 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1414 oc->flags |= AVFMT_FLAG_NONBLOCK;
1417 for (i = 0; i < o->nb_metadata_map; i++) {
1419 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1421 if (in_file_index >= nb_input_files) {
1422 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1425 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1426 in_file_index >= 0 ?
1427 input_files[in_file_index]->ctx : NULL, o);
1431 if (o->chapters_input_file >= nb_input_files) {
1432 if (o->chapters_input_file == INT_MAX) {
1433 /* copy chapters from the first input file that has them*/
1434 o->chapters_input_file = -1;
1435 for (i = 0; i < nb_input_files; i++)
1436 if (input_files[i]->ctx->nb_chapters) {
1437 o->chapters_input_file = i;
1441 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1442 o->chapters_input_file);
1446 if (o->chapters_input_file >= 0)
1447 copy_chapters(input_files[o->chapters_input_file], of,
1448 !o->metadata_chapters_manual);
1450 /* copy global metadata by default */
1451 if (!o->metadata_global_manual && nb_input_files)
1452 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1453 AV_DICT_DONT_OVERWRITE);
1454 if (!o->metadata_streams_manual)
1455 for (i = of->ost_index; i < nb_output_streams; i++) {
1457 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1459 ist = input_streams[output_streams[i]->source_index];
1460 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1463 /* process manually set metadata */
1464 for (i = 0; i < o->nb_metadata; i++) {
1467 const char *stream_spec;
1468 int index = 0, j, ret;
1470 val = strchr(o->metadata[i].u.str, '=');
1472 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1473 o->metadata[i].u.str);
1478 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1480 for (j = 0; j < oc->nb_streams; j++) {
1481 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1482 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1493 if (index < 0 || index >= oc->nb_chapters) {
1494 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1497 m = &oc->chapters[index]->metadata;
1500 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1503 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1510 static int opt_target(void *optctx, const char *opt, const char *arg)
1512 OptionsContext *o = optctx;
1513 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1514 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1516 if (!strncmp(arg, "pal-", 4)) {
1519 } else if (!strncmp(arg, "ntsc-", 5)) {
1522 } else if (!strncmp(arg, "film-", 5)) {
1526 /* Try to determine PAL/NTSC by peeking in the input files */
1527 if (nb_input_files) {
1529 for (j = 0; j < nb_input_files; j++) {
1530 for (i = 0; i < input_files[j]->nb_streams; i++) {
1531 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1532 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1534 fr = c->time_base.den * 1000 / c->time_base.num;
1538 } else if ((fr == 29970) || (fr == 23976)) {
1543 if (norm != UNKNOWN)
1547 if (norm != UNKNOWN)
1548 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1551 if (norm == UNKNOWN) {
1552 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1553 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1554 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1558 if (!strcmp(arg, "vcd")) {
1559 opt_video_codec(o, "c:v", "mpeg1video");
1560 opt_audio_codec(o, "c:a", "mp2");
1561 parse_option(o, "f", "vcd", options);
1563 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1564 parse_option(o, "r", frame_rates[norm], options);
1565 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1567 opt_default(NULL, "b", "1150000");
1568 opt_default(NULL, "maxrate", "1150000");
1569 opt_default(NULL, "minrate", "1150000");
1570 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1572 opt_default(NULL, "b:a", "224000");
1573 parse_option(o, "ar", "44100", options);
1574 parse_option(o, "ac", "2", options);
1576 opt_default(NULL, "packetsize", "2324");
1577 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1579 /* We have to offset the PTS, so that it is consistent with the SCR.
1580 SCR starts at 36000, but the first two packs contain only padding
1581 and the first pack from the other stream, respectively, may also have
1582 been written before.
1583 So the real data starts at SCR 36000+3*1200. */
1584 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1585 } else if (!strcmp(arg, "svcd")) {
1587 opt_video_codec(o, "c:v", "mpeg2video");
1588 opt_audio_codec(o, "c:a", "mp2");
1589 parse_option(o, "f", "svcd", options);
1591 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1592 parse_option(o, "r", frame_rates[norm], options);
1593 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1595 opt_default(NULL, "b", "2040000");
1596 opt_default(NULL, "maxrate", "2516000");
1597 opt_default(NULL, "minrate", "0"); // 1145000;
1598 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1599 opt_default(NULL, "flags", "+scan_offset");
1602 opt_default(NULL, "b:a", "224000");
1603 parse_option(o, "ar", "44100", options);
1605 opt_default(NULL, "packetsize", "2324");
1607 } else if (!strcmp(arg, "dvd")) {
1609 opt_video_codec(o, "c:v", "mpeg2video");
1610 opt_audio_codec(o, "c:a", "ac3");
1611 parse_option(o, "f", "dvd", options);
1613 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1614 parse_option(o, "r", frame_rates[norm], options);
1615 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1617 opt_default(NULL, "b", "6000000");
1618 opt_default(NULL, "maxrate", "9000000");
1619 opt_default(NULL, "minrate", "0"); // 1500000;
1620 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1622 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1623 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1625 opt_default(NULL, "b:a", "448000");
1626 parse_option(o, "ar", "48000", options);
1628 } else if (!strncmp(arg, "dv", 2)) {
1630 parse_option(o, "f", "dv", options);
1632 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1633 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1634 norm == PAL ? "yuv420p" : "yuv411p", options);
1635 parse_option(o, "r", frame_rates[norm], options);
1637 parse_option(o, "ar", "48000", options);
1638 parse_option(o, "ac", "2", options);
1641 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1642 return AVERROR(EINVAL);
1647 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1649 av_free (vstats_filename);
1650 vstats_filename = av_strdup (arg);
1654 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1657 time_t today2 = time(NULL);
1658 struct tm *today = localtime(&today2);
1660 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1662 return opt_vstats_file(NULL, opt, filename);
1665 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1667 OptionsContext *o = optctx;
1668 return parse_option(o, "frames:v", arg, options);
1671 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1673 OptionsContext *o = optctx;
1674 return parse_option(o, "frames:a", arg, options);
1677 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1679 OptionsContext *o = optctx;
1680 return parse_option(o, "frames:d", arg, options);
1683 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1685 OptionsContext *o = optctx;
1686 return parse_option(o, "tag:v", arg, options);
1689 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1691 OptionsContext *o = optctx;
1692 return parse_option(o, "tag:a", arg, options);
1695 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1697 OptionsContext *o = optctx;
1698 return parse_option(o, "tag:s", arg, options);
1701 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1703 OptionsContext *o = optctx;
1704 return parse_option(o, "filter:v", arg, options);
1707 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1709 OptionsContext *o = optctx;
1710 return parse_option(o, "filter:a", arg, options);
1713 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1715 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1716 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1717 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1719 if (video_sync_method == VSYNC_AUTO)
1720 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1724 #if FF_API_DEINTERLACE
1725 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1727 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1733 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1735 int flags = av_parse_cpu_flags(arg);
1740 av_set_cpu_flags_mask(flags);
1744 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1746 OptionsContext *o = optctx;
1747 char layout_str[32];
1750 int ret, channels, ac_str_size;
1753 layout = av_get_channel_layout(arg);
1755 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1756 return AVERROR(EINVAL);
1758 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1759 ret = opt_default(NULL, opt, layout_str);
1763 /* set 'ac' option based on channel layout */
1764 channels = av_get_channel_layout_nb_channels(layout);
1765 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1766 stream_str = strchr(opt, ':');
1767 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1768 ac_str = av_mallocz(ac_str_size);
1770 return AVERROR(ENOMEM);
1771 av_strlcpy(ac_str, "ac", 3);
1773 av_strlcat(ac_str, stream_str, ac_str_size);
1774 ret = parse_option(o, ac_str, layout_str, options);
1780 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1782 OptionsContext *o = optctx;
1783 return parse_option(o, "q:a", arg, options);
1786 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1788 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1789 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1790 return AVERROR(ENOMEM);
1791 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1792 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1796 void show_help_default(const char *opt, const char *arg)
1798 /* per-file options have at least one of those set */
1799 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1800 int show_advanced = 0, show_avoptions = 0;
1803 if (!strcmp(opt, "long"))
1805 else if (!strcmp(opt, "full"))
1806 show_advanced = show_avoptions = 1;
1808 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1813 printf("Getting help:\n"
1814 " -h -- print basic options\n"
1815 " -h long -- print more options\n"
1816 " -h full -- print all options (including all format and codec specific options, very long)\n"
1817 " See man %s for detailed description of the options.\n"
1818 "\n", program_name);
1820 show_help_options(options, "Print help / information / capabilities:",
1823 show_help_options(options, "Global options (affect whole program "
1824 "instead of just one file:",
1825 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1827 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1828 per_file | OPT_EXIT, 0);
1830 show_help_options(options, "Per-file main options:", 0,
1831 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1832 OPT_EXIT, per_file);
1834 show_help_options(options, "Advanced per-file options:",
1835 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1837 show_help_options(options, "Video options:",
1838 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1840 show_help_options(options, "Advanced Video options:",
1841 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1843 show_help_options(options, "Audio options:",
1844 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1846 show_help_options(options, "Advanced Audio options:",
1847 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1848 show_help_options(options, "Subtitle options:",
1849 OPT_SUBTITLE, 0, 0);
1852 if (show_avoptions) {
1853 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1854 show_help_children(avcodec_get_class(), flags);
1855 show_help_children(avformat_get_class(), flags);
1856 show_help_children(sws_get_class(), flags);
1860 void show_usage(void)
1862 printf("Hyper fast Audio and Video encoder\n");
1863 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1872 static const OptionGroupDef groups[] = {
1873 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
1874 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
1877 static int open_files(OptionGroupList *l, const char *inout,
1878 int (*open_file)(OptionsContext*, const char*))
1882 for (i = 0; i < l->nb_groups; i++) {
1883 OptionGroup *g = &l->groups[i];
1889 ret = parse_optgroup(&o, g);
1891 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1892 "%s.\n", inout, g->arg);
1896 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1897 ret = open_file(&o, g->arg);
1900 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1904 av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
1910 int avconv_parse_options(int argc, char **argv)
1912 OptionParseContext octx;
1916 memset(&octx, 0, sizeof(octx));
1918 /* split the commandline into an internal representation */
1919 ret = split_commandline(&octx, argc, argv, options, groups,
1920 FF_ARRAY_ELEMS(groups));
1922 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1926 /* apply global options */
1927 ret = parse_optgroup(NULL, &octx.global_opts);
1929 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1933 /* open input files */
1934 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1936 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1940 /* open output files */
1941 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1943 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1948 uninit_parse_context(&octx);
1950 av_strerror(ret, error, sizeof(error));
1951 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1956 #define OFFSET(x) offsetof(OptionsContext, x)
1957 const OptionDef options[] = {
1959 #include "cmdutils_common_opts.h"
1960 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
1961 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
1962 "force format", "fmt" },
1963 { "y", OPT_BOOL, { &file_overwrite },
1964 "overwrite output files" },
1965 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
1966 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
1967 "codec name", "codec" },
1968 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
1969 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
1970 "codec name", "codec" },
1971 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
1972 OPT_OUTPUT, { .off = OFFSET(presets) },
1973 "preset name", "preset" },
1974 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
1975 OPT_OUTPUT, { .func_arg = opt_map },
1976 "set input stream mapping",
1977 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1978 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
1979 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
1980 "set metadata information of outfile from infile",
1981 "outfile[,metadata]:infile[,metadata]" },
1982 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
1983 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
1984 "set chapters mapping", "input_file_index" },
1985 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
1986 "record or transcode \"duration\" seconds of audio/video",
1988 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
1989 "set the limit file size in bytes", "limit_size" },
1990 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
1991 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
1992 "set the start time offset", "time_off" },
1993 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
1994 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
1995 "set the input ts offset", "time_off" },
1996 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
1997 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
1998 "set the input ts scale", "scale" },
1999 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2000 "add metadata", "string=string" },
2001 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2002 OPT_OUTPUT, { .func_arg = opt_data_frames },
2003 "set the number of data frames to record", "number" },
2004 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2005 "add timings for benchmarking" },
2006 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2007 "set max runtime in seconds", "limit" },
2008 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2009 "dump each input packet" },
2010 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2011 "when dumping packets, also dump the payload" },
2012 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2013 OPT_INPUT, { .off = OFFSET(rate_emu) },
2014 "read input at native frame rate", "" },
2015 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2016 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2017 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2018 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2019 "video sync method", "" },
2020 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2021 "audio sync method", "" },
2022 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2023 "audio drift threshold", "threshold" },
2024 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2025 "copy timestamps" },
2026 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2027 "copy input stream time base when stream copying" },
2028 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2029 OPT_OUTPUT, { .off = OFFSET(shortest) },
2030 "finish encoding within shortest input" },
2031 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2032 "timestamp discontinuity delta threshold", "threshold" },
2033 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2034 "exit on error", "error" },
2035 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2036 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2037 "copy initial non-keyframes" },
2038 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2039 "set the number of frames to record", "number" },
2040 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2041 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2042 "force codec tag/fourcc", "fourcc/tag" },
2043 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2044 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2045 "use fixed quality scale (VBR)", "q" },
2046 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2047 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2048 "use fixed quality scale (VBR)", "q" },
2049 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2050 "set stream filterchain", "filter_list" },
2051 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2052 "create a complex filtergraph", "graph_description" },
2053 { "stats", OPT_BOOL, { &print_stats },
2054 "print progress report during encoding", },
2055 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2056 OPT_OUTPUT, { .func_arg = opt_attach },
2057 "add an attachment to the output file", "filename" },
2058 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2059 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2060 "extract an attachment into a file", "filename" },
2061 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
2062 "set CPU flags mask", "mask" },
2065 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2066 "set the number of video frames to record", "number" },
2067 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2068 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2069 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2070 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2071 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2072 "set frame size (WxH or abbreviation)", "size" },
2073 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2074 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2075 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2076 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2077 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2078 "set pixel format", "format" },
2079 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2081 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2082 "discard threshold", "n" },
2083 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2084 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2085 "rate control override for specific intervals", "override" },
2086 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2087 OPT_OUTPUT, { .func_arg = opt_video_codec },
2088 "force video codec ('copy' to copy stream)", "codec" },
2089 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2090 "select the pass number (1 or 2)", "n" },
2091 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2092 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2093 "select two pass log file name prefix", "prefix" },
2094 #if FF_API_DEINTERLACE
2095 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2096 "this option is deprecated, use the yadif filter instead" },
2098 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2099 "dump video coding statistics to file" },
2100 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2101 "dump video coding statistics to file", "file" },
2102 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2103 "video filters", "filter list" },
2104 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2105 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2106 "specify intra matrix coeffs", "matrix" },
2107 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2108 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2109 "specify inter matrix coeffs", "matrix" },
2110 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2111 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2112 "top=1/bottom=0/auto=-1 field first", "" },
2113 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2114 "intra_dc_precision", "precision" },
2115 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2116 OPT_OUTPUT, { .func_arg = opt_video_tag },
2117 "force video tag/fourcc", "fourcc/tag" },
2118 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2119 "show QP histogram" },
2120 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2121 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2122 "force the selected framerate, disable the best supported framerate selection" },
2123 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2124 OPT_OUTPUT, { .func_arg = opt_streamid },
2125 "set the value of an outfile streamid", "streamIndex:value" },
2126 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2127 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2128 "force key frames at specified timestamps", "timestamps" },
2131 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2132 "set the number of audio frames to record", "number" },
2133 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2134 "set audio quality (codec-specific)", "quality", },
2135 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2136 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2137 "set audio sampling rate (in Hz)", "rate" },
2138 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2139 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2140 "set number of audio channels", "channels" },
2141 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2143 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2144 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2145 "force audio codec ('copy' to copy stream)", "codec" },
2146 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2147 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2148 "force audio tag/fourcc", "fourcc/tag" },
2149 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2150 "change audio volume (256=normal)" , "volume" },
2151 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2152 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2153 "set sample format", "format" },
2154 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2155 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2156 "set channel layout", "layout" },
2157 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2158 "audio filters", "filter list" },
2160 /* subtitle options */
2161 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2162 "disable subtitle" },
2163 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2164 "force subtitle codec ('copy' to copy stream)", "codec" },
2165 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2166 , "force subtitle tag/fourcc", "fourcc/tag" },
2169 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2172 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2173 "set the maximum demux-decode delay", "seconds" },
2174 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2175 "set the initial demux-decode delay", "seconds" },
2177 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2178 "A comma-separated list of bitstream filters", "bitstream_filters" },
2180 /* data codec support */
2181 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2182 "force data codec ('copy' to copy stream)", "codec" },