2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
82 float audio_drift_threshold = 0.1;
83 float dts_delta_threshold = 10;
84 float dts_error_threshold = 3600*30;
86 int audio_volume = 256;
87 int audio_sync_method = 0;
88 int video_sync_method = VSYNC_AUTO;
89 float frame_drop_threshold = 0;
90 int do_deinterlace = 0;
92 int do_benchmark_all = 0;
96 int start_at_zero = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
102 int stdin_interaction = 1;
103 int frame_bits_per_raw_sample = 0;
104 float max_error_rate = 2.0/3;
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
113 static int input_stream_potentially_available = 0;
114 static int ignore_unknown_streams = 0;
115 static int copy_unknown_streams = 0;
117 static void uninit_options(OptionsContext *o)
119 const OptionDef *po = options;
122 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
124 void *dst = (uint8_t*)o + po->u.off;
126 if (po->flags & OPT_SPEC) {
127 SpecifierOpt **so = dst;
128 int i, *count = (int*)(so + 1);
129 for (i = 0; i < *count; i++) {
130 av_freep(&(*so)[i].specifier);
131 if (po->flags & OPT_STRING)
132 av_freep(&(*so)[i].u.str);
136 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
141 for (i = 0; i < o->nb_stream_maps; i++)
142 av_freep(&o->stream_maps[i].linklabel);
143 av_freep(&o->stream_maps);
144 av_freep(&o->audio_channel_maps);
145 av_freep(&o->streamid_map);
146 av_freep(&o->attachments);
149 static void init_options(OptionsContext *o)
151 memset(o, 0, sizeof(*o));
153 o->stop_time = INT64_MAX;
154 o->mux_max_delay = 0.7;
155 o->start_time = AV_NOPTS_VALUE;
156 o->recording_time = INT64_MAX;
157 o->limit_filesize = UINT64_MAX;
158 o->chapters_input_file = INT_MAX;
159 o->accurate_seek = 1;
162 /* return a copy of the input with the stream specifiers removed from the keys */
163 static AVDictionary *strip_specifiers(AVDictionary *dict)
165 AVDictionaryEntry *e = NULL;
166 AVDictionary *ret = NULL;
168 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
169 char *p = strchr(e->key, ':');
173 av_dict_set(&ret, e->key, e->value, 0);
180 static int opt_sameq(void *optctx, const char *opt, const char *arg)
182 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
183 "If you are looking for an option to preserve the quality (which is not "
184 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
186 return AVERROR(EINVAL);
189 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
191 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
192 return opt_default(optctx, "channel", arg);
195 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
197 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
198 return opt_default(optctx, "standard", arg);
201 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:a", arg, options);
207 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:v", arg, options);
213 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:s", arg, options);
219 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
221 OptionsContext *o = optctx;
222 return parse_option(o, "codec:d", arg, options);
225 static int opt_map(void *optctx, const char *opt, const char *arg)
227 OptionsContext *o = optctx;
229 int i, negative = 0, file_idx;
230 int sync_file_idx = -1, sync_stream_idx = 0;
238 map = av_strdup(arg);
240 return AVERROR(ENOMEM);
242 /* parse sync stream first, just pick first matching stream */
243 if (sync = strchr(map, ',')) {
245 sync_file_idx = strtol(sync + 1, &sync, 0);
246 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
247 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
252 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
253 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
254 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
258 if (i == input_files[sync_file_idx]->nb_streams) {
259 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
260 "match any streams.\n", arg);
267 /* this mapping refers to lavfi output */
268 const char *c = map + 1;
269 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
270 m = &o->stream_maps[o->nb_stream_maps - 1];
271 m->linklabel = av_get_token(&c, "]");
273 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
277 file_idx = strtol(map, &p, 0);
278 if (file_idx >= nb_input_files || file_idx < 0) {
279 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
283 /* disable some already defined maps */
284 for (i = 0; i < o->nb_stream_maps; i++) {
285 m = &o->stream_maps[i];
286 if (file_idx == m->file_index &&
287 check_stream_specifier(input_files[m->file_index]->ctx,
288 input_files[m->file_index]->ctx->streams[m->stream_index],
289 *p == ':' ? p + 1 : p) > 0)
293 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
294 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
295 *p == ':' ? p + 1 : p) <= 0)
297 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
298 m = &o->stream_maps[o->nb_stream_maps - 1];
300 m->file_index = file_idx;
303 if (sync_file_idx >= 0) {
304 m->sync_file_index = sync_file_idx;
305 m->sync_stream_index = sync_stream_idx;
307 m->sync_file_index = file_idx;
308 m->sync_stream_index = i;
314 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
322 static int opt_attach(void *optctx, const char *opt, const char *arg)
324 OptionsContext *o = optctx;
325 GROW_ARRAY(o->attachments, o->nb_attachments);
326 o->attachments[o->nb_attachments - 1] = arg;
330 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
332 OptionsContext *o = optctx;
337 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
338 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
340 /* muted channel syntax */
341 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
342 if ((n == 1 || n == 3) && m->channel_idx == -1) {
343 m->file_idx = m->stream_idx = -1;
345 m->ofile_idx = m->ostream_idx = -1;
350 n = sscanf(arg, "%d.%d.%d:%d.%d",
351 &m->file_idx, &m->stream_idx, &m->channel_idx,
352 &m->ofile_idx, &m->ostream_idx);
354 if (n != 3 && n != 5) {
355 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
356 "[file.stream.channel|-1][:syncfile:syncstream]\n");
360 if (n != 5) // only file.stream.channel specified
361 m->ofile_idx = m->ostream_idx = -1;
364 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
369 if (m->stream_idx < 0 ||
370 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
371 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
372 m->file_idx, m->stream_idx);
375 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
376 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
377 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
378 m->file_idx, m->stream_idx);
381 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
382 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
383 m->file_idx, m->stream_idx, m->channel_idx);
389 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
391 av_free(sdp_filename);
392 sdp_filename = av_strdup(arg);
397 * Parse a metadata specifier passed as 'arg' parameter.
398 * @param arg metadata string to parse
399 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
400 * @param index for type c/p, chapter/program index is written here
401 * @param stream_spec for type s, the stream specifier is written here
403 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
411 if (*(++arg) && *arg != ':') {
412 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
415 *stream_spec = *arg == ':' ? arg + 1 : "";
420 *index = strtol(++arg, NULL, 0);
423 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
430 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
432 AVDictionary **meta_in = NULL;
433 AVDictionary **meta_out = NULL;
435 char type_in, type_out;
436 const char *istream_spec = NULL, *ostream_spec = NULL;
437 int idx_in = 0, idx_out = 0;
439 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
440 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
443 if (type_out == 'g' || !*outspec)
444 o->metadata_global_manual = 1;
445 if (type_out == 's' || !*outspec)
446 o->metadata_streams_manual = 1;
447 if (type_out == 'c' || !*outspec)
448 o->metadata_chapters_manual = 1;
452 if (type_in == 'g' || type_out == 'g')
453 o->metadata_global_manual = 1;
454 if (type_in == 's' || type_out == 's')
455 o->metadata_streams_manual = 1;
456 if (type_in == 'c' || type_out == 'c')
457 o->metadata_chapters_manual = 1;
459 /* ic is NULL when just disabling automatic mappings */
463 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
464 if ((index) < 0 || (index) >= (nb_elems)) {\
465 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
470 #define SET_DICT(type, meta, context, index)\
473 meta = &context->metadata;\
476 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
477 meta = &context->chapters[index]->metadata;\
480 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
481 meta = &context->programs[index]->metadata;\
484 break; /* handled separately below */ \
485 default: av_assert0(0);\
488 SET_DICT(type_in, meta_in, ic, idx_in);
489 SET_DICT(type_out, meta_out, oc, idx_out);
491 /* for input streams choose first matching stream */
492 if (type_in == 's') {
493 for (i = 0; i < ic->nb_streams; i++) {
494 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
495 meta_in = &ic->streams[i]->metadata;
501 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
506 if (type_out == 's') {
507 for (i = 0; i < oc->nb_streams; i++) {
508 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
509 meta_out = &oc->streams[i]->metadata;
510 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
515 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
520 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
522 OptionsContext *o = optctx;
524 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
525 struct tm time = *gmtime((time_t*)&recording_timestamp);
526 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
528 parse_option(o, "metadata", buf, options);
530 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
531 "tag instead.\n", opt);
535 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
537 const AVCodecDescriptor *desc;
538 const char *codec_string = encoder ? "encoder" : "decoder";
542 avcodec_find_encoder_by_name(name) :
543 avcodec_find_decoder_by_name(name);
545 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
546 codec = encoder ? avcodec_find_encoder(desc->id) :
547 avcodec_find_decoder(desc->id);
549 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
550 codec_string, codec->name, desc->name);
554 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
557 if (codec->type != type) {
558 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
564 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
566 char *codec_name = NULL;
568 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
570 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
571 st->codec->codec_id = codec->id;
574 return avcodec_find_decoder(st->codec->codec_id);
577 /* Add all the streams from the given input file to the global
578 * list of input streams. */
579 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
583 for (i = 0; i < ic->nb_streams; i++) {
584 AVStream *st = ic->streams[i];
585 AVCodecContext *dec = st->codec;
586 InputStream *ist = av_mallocz(sizeof(*ist));
587 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
588 char *codec_tag = NULL;
590 char *discard_str = NULL;
591 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
596 GROW_ARRAY(input_streams, nb_input_streams);
597 input_streams[nb_input_streams - 1] = ist;
600 ist->file_index = nb_input_files;
602 st->discard = AVDISCARD_ALL;
605 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
608 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
610 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
612 uint32_t tag = strtol(codec_tag, &next, 0);
614 tag = AV_RL32(codec_tag);
615 st->codec->codec_tag = tag;
618 ist->dec = choose_decoder(o, ic, st);
619 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
621 ist->reinit_filters = -1;
622 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
624 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
625 ist->user_set_discard = AVDISCARD_NONE;
626 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
627 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
632 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
634 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
636 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
640 ret = avcodec_copy_context(ist->dec_ctx, dec);
642 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
646 switch (dec->codec_type) {
647 case AVMEDIA_TYPE_VIDEO:
649 ist->dec = avcodec_find_decoder(dec->codec_id);
650 if (av_codec_get_lowres(dec)) {
651 dec->flags |= CODEC_FLAG_EMU_EDGE;
654 ist->resample_height = ist->dec_ctx->height;
655 ist->resample_width = ist->dec_ctx->width;
656 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
658 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
659 if (framerate && av_parse_video_rate(&ist->framerate,
661 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
666 ist->top_field_first = -1;
667 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
669 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
671 if (!strcmp(hwaccel, "none"))
672 ist->hwaccel_id = HWACCEL_NONE;
673 else if (!strcmp(hwaccel, "auto"))
674 ist->hwaccel_id = HWACCEL_AUTO;
677 for (i = 0; hwaccels[i].name; i++) {
678 if (!strcmp(hwaccels[i].name, hwaccel)) {
679 ist->hwaccel_id = hwaccels[i].id;
684 if (!ist->hwaccel_id) {
685 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
687 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
688 for (i = 0; hwaccels[i].name; i++)
689 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
690 av_log(NULL, AV_LOG_FATAL, "\n");
696 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
697 if (hwaccel_device) {
698 ist->hwaccel_device = av_strdup(hwaccel_device);
699 if (!ist->hwaccel_device)
702 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
705 case AVMEDIA_TYPE_AUDIO:
706 ist->guess_layout_max = INT_MAX;
707 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
708 guess_input_channel_layout(ist);
710 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
711 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
712 ist->resample_channels = ist->dec_ctx->channels;
713 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
716 case AVMEDIA_TYPE_DATA:
717 case AVMEDIA_TYPE_SUBTITLE: {
718 char *canvas_size = NULL;
720 ist->dec = avcodec_find_decoder(dec->codec_id);
721 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
722 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
724 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
725 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
730 case AVMEDIA_TYPE_ATTACHMENT:
731 case AVMEDIA_TYPE_UNKNOWN:
739 static void assert_file_overwrite(const char *filename)
741 if (file_overwrite && no_file_overwrite) {
742 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
746 if (!file_overwrite) {
747 const char *proto_name = avio_find_protocol_name(filename);
748 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
749 if (stdin_interaction && !no_file_overwrite) {
750 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
753 signal(SIGINT, SIG_DFL);
755 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
761 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
768 static void dump_attachment(AVStream *st, const char *filename)
771 AVIOContext *out = NULL;
772 AVDictionaryEntry *e;
774 if (!st->codec->extradata_size) {
775 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
776 nb_input_files - 1, st->index);
779 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
782 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
783 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
787 assert_file_overwrite(filename);
789 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
790 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
795 avio_write(out, st->codec->extradata, st->codec->extradata_size);
800 static int open_input_file(OptionsContext *o, const char *filename)
804 AVInputFormat *file_iformat = NULL;
808 AVDictionary *unused_opts = NULL;
809 AVDictionaryEntry *e = NULL;
810 int orig_nb_streams; // number of streams before avformat_find_stream_info
811 char * video_codec_name = NULL;
812 char * audio_codec_name = NULL;
813 char *subtitle_codec_name = NULL;
814 char * data_codec_name = NULL;
815 int scan_all_pmts_set = 0;
818 if (!(file_iformat = av_find_input_format(o->format))) {
819 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
824 if (!strcmp(filename, "-"))
827 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
828 strcmp(filename, "/dev/stdin");
830 /* get default parameters from command line */
831 ic = avformat_alloc_context();
833 print_error(filename, AVERROR(ENOMEM));
836 if (o->nb_audio_sample_rate) {
837 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
839 if (o->nb_audio_channels) {
840 /* because we set audio_channels based on both the "ac" and
841 * "channel_layout" options, we need to check that the specified
842 * demuxer actually has the "channels" option before setting it */
843 if (file_iformat && file_iformat->priv_class &&
844 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
845 AV_OPT_SEARCH_FAKE_OBJ)) {
846 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
849 if (o->nb_frame_rates) {
850 /* set the format-level framerate option;
851 * this is important for video grabbers, e.g. x11 */
852 if (file_iformat && file_iformat->priv_class &&
853 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
854 AV_OPT_SEARCH_FAKE_OBJ)) {
855 av_dict_set(&o->g->format_opts, "framerate",
856 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
859 if (o->nb_frame_sizes) {
860 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
862 if (o->nb_frame_pix_fmts)
863 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
865 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
866 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
867 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
868 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
870 ic->video_codec_id = video_codec_name ?
871 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
872 ic->audio_codec_id = audio_codec_name ?
873 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
874 ic->subtitle_codec_id= subtitle_codec_name ?
875 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
876 ic->data_codec_id = data_codec_name ?
877 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
879 if (video_codec_name)
880 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
881 if (audio_codec_name)
882 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
883 if (subtitle_codec_name)
884 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
886 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
888 ic->flags |= AVFMT_FLAG_NONBLOCK;
889 ic->interrupt_callback = int_cb;
891 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
892 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
893 scan_all_pmts_set = 1;
895 /* open the input file with generic avformat function */
896 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
898 print_error(filename, err);
901 if (scan_all_pmts_set)
902 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
903 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
904 assert_avoptions(o->g->format_opts);
906 /* apply forced codec ids */
907 for (i = 0; i < ic->nb_streams; i++)
908 choose_decoder(o, ic, ic->streams[i]);
910 /* Set AVCodecContext options for avformat_find_stream_info */
911 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
912 orig_nb_streams = ic->nb_streams;
914 /* If not enough info to get the stream parameters, we decode the
915 first frames to get it. (used in mpeg case for example) */
916 ret = avformat_find_stream_info(ic, opts);
918 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
919 if (ic->nb_streams == 0) {
920 avformat_close_input(&ic);
925 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
926 /* add the stream start time */
927 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
928 timestamp += ic->start_time;
930 /* if seeking requested, we execute it */
931 if (o->start_time != AV_NOPTS_VALUE) {
932 int64_t seek_timestamp = timestamp;
934 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
935 int dts_heuristic = 0;
936 for (i=0; i<ic->nb_streams; i++) {
937 AVCodecContext *avctx = ic->streams[i]->codec;
938 if (avctx->has_b_frames)
942 seek_timestamp -= 3*AV_TIME_BASE / 23;
945 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
947 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
948 filename, (double)timestamp / AV_TIME_BASE);
952 /* update the current parameters so that they match the one of the input stream */
953 add_input_streams(o, ic);
955 /* dump the file content */
956 av_dump_format(ic, nb_input_files, filename, 0);
958 GROW_ARRAY(input_files, nb_input_files);
959 f = av_mallocz(sizeof(*f));
962 input_files[nb_input_files - 1] = f;
965 f->ist_index = nb_input_streams - ic->nb_streams;
966 f->start_time = o->start_time;
967 f->recording_time = o->recording_time;
968 f->input_ts_offset = o->input_ts_offset;
969 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
970 f->nb_streams = ic->nb_streams;
971 f->rate_emu = o->rate_emu;
972 f->accurate_seek = o->accurate_seek;
974 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
977 /* check if all codec options have been used */
978 unused_opts = strip_specifiers(o->g->codec_opts);
979 for (i = f->ist_index; i < nb_input_streams; i++) {
981 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
982 AV_DICT_IGNORE_SUFFIX)))
983 av_dict_set(&unused_opts, e->key, NULL, 0);
987 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
988 const AVClass *class = avcodec_get_class();
989 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
990 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
991 const AVClass *fclass = avformat_get_class();
992 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
993 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
994 if (!option || foption)
998 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
999 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1000 "input file #%d (%s) is not a decoding option.\n", e->key,
1001 option->help ? option->help : "", nb_input_files - 1,
1006 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1007 "input file #%d (%s) has not been used for any stream. The most "
1008 "likely reason is either wrong type (e.g. a video option with "
1009 "no video streams) or that it is a private option of some decoder "
1010 "which was not actually used for any stream.\n", e->key,
1011 option->help ? option->help : "", nb_input_files - 1, filename);
1013 av_dict_free(&unused_opts);
1015 for (i = 0; i < o->nb_dump_attachment; i++) {
1018 for (j = 0; j < ic->nb_streams; j++) {
1019 AVStream *st = ic->streams[j];
1021 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1022 dump_attachment(st, o->dump_attachment[i].u.str);
1026 for (i = 0; i < orig_nb_streams; i++)
1027 av_dict_free(&opts[i]);
1030 input_stream_potentially_available = 1;
1035 static uint8_t *get_line(AVIOContext *s)
1041 if (avio_open_dyn_buf(&line) < 0) {
1042 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1046 while ((c = avio_r8(s)) && c != '\n')
1049 avio_close_dyn_buf(line, &buf);
1054 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1057 char filename[1000];
1058 const char *base[3] = { getenv("AVCONV_DATADIR"),
1063 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1067 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1068 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1069 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1072 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1073 i != 1 ? "" : "/.avconv", preset_name);
1074 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1080 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1082 char *codec_name = NULL;
1084 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1086 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1087 NULL, ost->st->codec->codec_type);
1088 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1089 } else if (!strcmp(codec_name, "copy"))
1090 ost->stream_copy = 1;
1092 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1093 ost->st->codec->codec_id = ost->enc->id;
1097 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1100 AVStream *st = avformat_new_stream(oc, NULL);
1101 int idx = oc->nb_streams - 1, ret = 0;
1102 char *bsf = NULL, *next, *codec_tag = NULL;
1103 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1108 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1112 if (oc->nb_streams - 1 < o->nb_streamid_map)
1113 st->id = o->streamid_map[oc->nb_streams - 1];
1115 GROW_ARRAY(output_streams, nb_output_streams);
1116 if (!(ost = av_mallocz(sizeof(*ost))))
1118 output_streams[nb_output_streams - 1] = ost;
1120 ost->file_index = nb_output_files - 1;
1123 st->codec->codec_type = type;
1124 choose_encoder(o, oc, ost);
1126 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1127 if (!ost->enc_ctx) {
1128 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1131 ost->enc_ctx->codec_type = type;
1134 AVIOContext *s = NULL;
1135 char *buf = NULL, *arg = NULL, *preset = NULL;
1137 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1139 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1140 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1143 if (!buf[0] || buf[0] == '#') {
1147 if (!(arg = strchr(buf, '='))) {
1148 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1152 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1154 } while (!s->eof_reached);
1158 av_log(NULL, AV_LOG_FATAL,
1159 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1160 preset, ost->file_index, ost->index);
1164 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1167 ost->max_frames = INT64_MAX;
1168 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1169 for (i = 0; i<o->nb_max_frames; i++) {
1170 char *p = o->max_frames[i].specifier;
1171 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1172 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1177 ost->copy_prior_start = -1;
1178 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1180 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1183 if (next = strchr(bsf, ','))
1185 if (arg = strchr(bsf, '='))
1187 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1188 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1192 bsfc_prev->next = bsfc;
1194 ost->bitstream_filters = bsfc;
1195 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1201 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1203 uint32_t tag = strtol(codec_tag, &next, 0);
1205 tag = AV_RL32(codec_tag);
1206 ost->enc_ctx->codec_tag = tag;
1209 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1211 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1212 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1215 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1216 ost->disposition = av_strdup(ost->disposition);
1218 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1219 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1221 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1223 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1224 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1225 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1227 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1229 ost->source_index = source_index;
1230 if (source_index >= 0) {
1231 ost->sync_ist = input_streams[source_index];
1232 input_streams[source_index]->discard = 0;
1233 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1235 ost->last_mux_dts = AV_NOPTS_VALUE;
1240 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1243 const char *p = str;
1250 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1257 /* read file contents into a string */
1258 static uint8_t *read_file(const char *filename)
1260 AVIOContext *pb = NULL;
1261 AVIOContext *dyn_buf = NULL;
1262 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1263 uint8_t buf[1024], *str;
1266 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1270 ret = avio_open_dyn_buf(&dyn_buf);
1275 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1276 avio_write(dyn_buf, buf, ret);
1277 avio_w8(dyn_buf, 0);
1280 ret = avio_close_dyn_buf(dyn_buf, &str);
1286 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1289 AVStream *st = ost->st;
1291 if (ost->filters_script && ost->filters) {
1292 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1293 "output stream #%d:%d.\n", nb_output_files, st->index);
1297 if (ost->filters_script)
1298 return read_file(ost->filters_script);
1299 else if (ost->filters)
1300 return av_strdup(ost->filters);
1302 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1306 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1307 const OutputStream *ost, enum AVMediaType type)
1309 if (ost->filters_script || ost->filters) {
1310 av_log(NULL, AV_LOG_ERROR,
1311 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1312 "Filtering and streamcopy cannot be used together.\n",
1313 ost->filters ? "Filtergraph" : "Filtergraph script",
1314 ost->filters ? ost->filters : ost->filters_script,
1315 av_get_media_type_string(type), ost->file_index, ost->index);
1320 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1324 AVCodecContext *video_enc;
1325 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1327 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1329 video_enc = ost->enc_ctx;
1331 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1332 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1333 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1336 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1337 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1339 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1340 if (frame_aspect_ratio) {
1342 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1343 q.num <= 0 || q.den <= 0) {
1344 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1347 ost->frame_aspect_ratio = q;
1350 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1351 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1353 if (!ost->stream_copy) {
1354 const char *p = NULL;
1355 char *frame_size = NULL;
1356 char *frame_pix_fmt = NULL;
1357 char *intra_matrix = NULL, *inter_matrix = NULL;
1358 char *chroma_intra_matrix = NULL;
1362 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1363 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1364 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1368 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1369 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1370 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1371 ost->keep_pix_fmt = 1;
1372 if (!*++frame_pix_fmt)
1373 frame_pix_fmt = NULL;
1375 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1376 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1379 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1382 video_enc->gop_size = 0;
1383 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1385 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1386 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1389 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1391 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1392 if (chroma_intra_matrix) {
1393 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1395 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1398 av_codec_set_chroma_intra_matrix(video_enc, p);
1399 parse_matrix_coeffs(p, chroma_intra_matrix);
1401 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1403 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1404 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1407 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1410 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1411 for (i = 0; p; i++) {
1413 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1415 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1418 video_enc->rc_override =
1419 av_realloc_array(video_enc->rc_override,
1420 i + 1, sizeof(RcOverride));
1421 if (!video_enc->rc_override) {
1422 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1425 video_enc->rc_override[i].start_frame = start;
1426 video_enc->rc_override[i].end_frame = end;
1428 video_enc->rc_override[i].qscale = q;
1429 video_enc->rc_override[i].quality_factor = 1.0;
1432 video_enc->rc_override[i].qscale = 0;
1433 video_enc->rc_override[i].quality_factor = -q/100.0;
1438 video_enc->rc_override_count = i;
1441 video_enc->flags|= CODEC_FLAG_PSNR;
1444 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1447 video_enc->flags |= CODEC_FLAG_PASS1;
1448 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1451 video_enc->flags |= CODEC_FLAG_PASS2;
1452 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1456 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1457 if (ost->logfile_prefix &&
1458 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1461 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1462 if (ost->forced_keyframes)
1463 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1465 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1467 ost->top_field_first = -1;
1468 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1471 ost->avfilter = get_ost_filters(o, oc, ost);
1475 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1478 if (ost->stream_copy)
1479 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1484 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1489 AVCodecContext *audio_enc;
1491 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1494 audio_enc = ost->enc_ctx;
1495 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1497 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1498 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1500 if (!ost->stream_copy) {
1501 char *sample_fmt = NULL;
1503 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1505 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1507 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1508 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1512 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1514 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1515 ost->apad = av_strdup(ost->apad);
1517 ost->avfilter = get_ost_filters(o, oc, ost);
1521 /* check for channel mapping for this audio stream */
1522 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1523 AudioChannelMap *map = &o->audio_channel_maps[n];
1524 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1525 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1528 if (map->channel_idx == -1) {
1530 } else if (ost->source_index < 0) {
1531 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1532 ost->file_index, ost->st->index);
1535 ist = input_streams[ost->source_index];
1538 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1539 if (av_reallocp_array(&ost->audio_channels_map,
1540 ost->audio_channels_mapped + 1,
1541 sizeof(*ost->audio_channels_map)
1545 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1551 if (ost->stream_copy)
1552 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1557 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1561 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1562 if (!ost->stream_copy) {
1563 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1570 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1574 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1575 if (!ost->stream_copy) {
1576 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1583 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1585 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1586 ost->stream_copy = 1;
1591 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1595 AVCodecContext *subtitle_enc;
1597 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1599 subtitle_enc = ost->enc_ctx;
1601 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1603 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1605 if (!ost->stream_copy) {
1606 char *frame_size = NULL;
1608 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1609 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1610 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1618 /* arg format is "output-stream-index:streamid-value". */
1619 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1621 OptionsContext *o = optctx;
1626 av_strlcpy(idx_str, arg, sizeof(idx_str));
1627 p = strchr(idx_str, ':');
1629 av_log(NULL, AV_LOG_FATAL,
1630 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1635 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1636 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1637 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1641 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1643 AVFormatContext *is = ifile->ctx;
1644 AVFormatContext *os = ofile->ctx;
1648 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1650 return AVERROR(ENOMEM);
1653 for (i = 0; i < is->nb_chapters; i++) {
1654 AVChapter *in_ch = is->chapters[i], *out_ch;
1655 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1656 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1657 AV_TIME_BASE_Q, in_ch->time_base);
1658 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1659 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1662 if (in_ch->end < ts_off)
1664 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1667 out_ch = av_mallocz(sizeof(AVChapter));
1669 return AVERROR(ENOMEM);
1671 out_ch->id = in_ch->id;
1672 out_ch->time_base = in_ch->time_base;
1673 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1674 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1677 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1679 os->chapters[os->nb_chapters++] = out_ch;
1684 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1687 AVFormatContext *ic = avformat_alloc_context();
1689 ic->interrupt_callback = int_cb;
1690 err = avformat_open_input(&ic, filename, NULL, NULL);
1693 /* copy stream format */
1694 for(i=0;i<ic->nb_streams;i++) {
1698 const char *enc_config;
1700 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1702 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1703 return AVERROR(EINVAL);
1705 if (codec->type == AVMEDIA_TYPE_AUDIO)
1706 opt_audio_codec(o, "c:a", codec->name);
1707 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1708 opt_video_codec(o, "c:v", codec->name);
1709 ost = new_output_stream(o, s, codec->type, -1);
1712 avcodec_get_context_defaults3(st->codec, codec);
1713 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1715 AVDictionary *opts = NULL;
1716 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1717 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1718 av_dict_free(&opts);
1721 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1722 choose_sample_fmt(st, codec);
1723 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1724 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1725 avcodec_copy_context(ost->enc_ctx, st->codec);
1727 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1730 avformat_close_input(&ic);
1734 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1735 AVFormatContext *oc)
1739 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1740 ofilter->out_tmp->pad_idx)) {
1741 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1742 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1744 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1749 ost->source_index = -1;
1750 ost->filter = ofilter;
1754 if (ost->stream_copy) {
1755 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1756 "which is fed from a complex filtergraph. Filtering and streamcopy "
1757 "cannot be used together.\n", ost->file_index, ost->index);
1761 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1762 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1763 av_log(NULL, AV_LOG_ERROR,
1764 "%s '%s' was specified through the %s option "
1765 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1766 "%s and -filter_complex cannot be used together for the same stream.\n",
1767 ost->filters ? "Filtergraph" : "Filtergraph script",
1768 ost->filters ? ost->filters : ost->filters_script,
1769 opt, ost->file_index, ost->index, opt);
1773 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1774 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1777 avfilter_inout_free(&ofilter->out_tmp);
1780 static int configure_complex_filters(void)
1784 for (i = 0; i < nb_filtergraphs; i++)
1785 if (!filtergraphs[i]->graph &&
1786 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1791 static int open_output_file(OptionsContext *o, const char *filename)
1793 AVFormatContext *oc;
1795 AVOutputFormat *file_oformat;
1799 AVDictionary *unused_opts = NULL;
1800 AVDictionaryEntry *e = NULL;
1802 if (configure_complex_filters() < 0) {
1803 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1807 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1808 o->stop_time = INT64_MAX;
1809 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1812 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1813 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1814 if (o->stop_time <= start_time) {
1815 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1818 o->recording_time = o->stop_time - start_time;
1822 GROW_ARRAY(output_files, nb_output_files);
1823 of = av_mallocz(sizeof(*of));
1826 output_files[nb_output_files - 1] = of;
1828 of->ost_index = nb_output_streams;
1829 of->recording_time = o->recording_time;
1830 of->start_time = o->start_time;
1831 of->limit_filesize = o->limit_filesize;
1832 of->shortest = o->shortest;
1833 av_dict_copy(&of->opts, o->g->format_opts, 0);
1835 if (!strcmp(filename, "-"))
1838 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1840 print_error(filename, err);
1845 if (o->recording_time != INT64_MAX)
1846 oc->duration = o->recording_time;
1848 file_oformat= oc->oformat;
1849 oc->interrupt_callback = int_cb;
1851 /* create streams for all unlabeled output pads */
1852 for (i = 0; i < nb_filtergraphs; i++) {
1853 FilterGraph *fg = filtergraphs[i];
1854 for (j = 0; j < fg->nb_outputs; j++) {
1855 OutputFilter *ofilter = fg->outputs[j];
1857 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1860 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1861 ofilter->out_tmp->pad_idx)) {
1862 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1863 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1864 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1866 init_output_filter(ofilter, o, oc);
1870 /* ffserver seeking with date=... needs a date reference */
1871 if (!strcmp(file_oformat->name, "ffm") &&
1872 av_strstart(filename, "http:", NULL)) {
1873 int err = parse_option(o, "metadata", "creation_time=now", options);
1875 print_error(filename, err);
1880 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1881 av_strstart(filename, "http:", NULL)) {
1883 /* special case for files sent to ffserver: we get the stream
1884 parameters from ffserver */
1885 int err = read_ffserver_streams(o, oc, filename);
1887 print_error(filename, err);
1890 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1891 ost = output_streams[j];
1892 for (i = 0; i < nb_input_streams; i++) {
1893 ist = input_streams[i];
1894 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1896 ost->source_index= i;
1897 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1898 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1900 ist->st->discard = ist->user_set_discard;
1905 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1909 } else if (!o->nb_stream_maps) {
1910 char *subtitle_codec_name = NULL;
1911 /* pick the "best" stream of each type */
1913 /* video: highest resolution */
1914 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1915 int area = 0, idx = -1;
1916 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1917 for (i = 0; i < nb_input_streams; i++) {
1919 ist = input_streams[i];
1920 new_area = ist->st->codec->width * ist->st->codec->height;
1921 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1923 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1925 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1932 new_video_stream(o, oc, idx);
1935 /* audio: most channels */
1936 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1937 int channels = 0, idx = -1;
1938 for (i = 0; i < nb_input_streams; i++) {
1939 ist = input_streams[i];
1940 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1941 ist->st->codec->channels > channels) {
1942 channels = ist->st->codec->channels;
1947 new_audio_stream(o, oc, idx);
1950 /* subtitles: pick first */
1951 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1952 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1953 for (i = 0; i < nb_input_streams; i++)
1954 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1955 AVCodecDescriptor const *input_descriptor =
1956 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1957 AVCodecDescriptor const *output_descriptor = NULL;
1958 AVCodec const *output_codec =
1959 avcodec_find_encoder(oc->oformat->subtitle_codec);
1960 int input_props = 0, output_props = 0;
1962 output_descriptor = avcodec_descriptor_get(output_codec->id);
1963 if (input_descriptor)
1964 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1965 if (output_descriptor)
1966 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1967 if (subtitle_codec_name ||
1968 input_props & output_props ||
1969 // Map dvb teletext which has neither property to any output subtitle encoder
1970 input_descriptor && output_descriptor &&
1971 (!input_descriptor->props ||
1972 !output_descriptor->props)) {
1973 new_subtitle_stream(o, oc, i);
1978 /* Data only if codec id match */
1979 if (!o->data_disable ) {
1980 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1981 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1982 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1983 && input_streams[i]->st->codec->codec_id == codec_id )
1984 new_data_stream(o, oc, i);
1988 for (i = 0; i < o->nb_stream_maps; i++) {
1989 StreamMap *map = &o->stream_maps[i];
1994 if (map->linklabel) {
1996 OutputFilter *ofilter = NULL;
1999 for (j = 0; j < nb_filtergraphs; j++) {
2000 fg = filtergraphs[j];
2001 for (k = 0; k < fg->nb_outputs; k++) {
2002 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2003 if (out && !strcmp(out->name, map->linklabel)) {
2004 ofilter = fg->outputs[k];
2011 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2012 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2015 init_output_filter(ofilter, o, oc);
2017 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2019 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2020 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2022 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2024 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2026 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2029 switch (ist->st->codec->codec_type) {
2030 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2031 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2032 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2033 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2034 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2035 case AVMEDIA_TYPE_UNKNOWN:
2036 if (copy_unknown_streams) {
2037 ost = new_unknown_stream (o, oc, src_idx);
2041 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2042 "Cannot map stream #%d:%d - unsupported type.\n",
2043 map->file_index, map->stream_index);
2044 if (!ignore_unknown_streams) {
2045 av_log(NULL, AV_LOG_FATAL,
2046 "If you want unsupported types ignored instead "
2047 "of failing, please use the -ignore_unknown option\n"
2048 "If you want them copied, please use -copy_unknown\n");
2056 /* handle attached files */
2057 for (i = 0; i < o->nb_attachments; i++) {
2059 uint8_t *attachment;
2063 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2064 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2068 if ((len = avio_size(pb)) <= 0) {
2069 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2073 if (!(attachment = av_malloc(len))) {
2074 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2078 avio_read(pb, attachment, len);
2080 ost = new_attachment_stream(o, oc, -1);
2081 ost->stream_copy = 0;
2082 ost->attachment_filename = o->attachments[i];
2084 ost->st->codec->extradata = attachment;
2085 ost->st->codec->extradata_size = len;
2087 p = strrchr(o->attachments[i], '/');
2088 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2092 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2093 AVDictionaryEntry *e;
2094 ost = output_streams[i];
2096 if ((ost->stream_copy || ost->attachment_filename)
2097 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2098 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2099 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2103 /* check if all codec options have been used */
2104 unused_opts = strip_specifiers(o->g->codec_opts);
2105 for (i = of->ost_index; i < nb_output_streams; i++) {
2107 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2108 AV_DICT_IGNORE_SUFFIX)))
2109 av_dict_set(&unused_opts, e->key, NULL, 0);
2113 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2114 const AVClass *class = avcodec_get_class();
2115 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2116 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2117 const AVClass *fclass = avformat_get_class();
2118 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2119 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2120 if (!option || foption)
2124 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2125 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2126 "output file #%d (%s) is not an encoding option.\n", e->key,
2127 option->help ? option->help : "", nb_output_files - 1,
2132 // gop_timecode is injected by generic code but not always used
2133 if (!strcmp(e->key, "gop_timecode"))
2136 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2137 "output file #%d (%s) has not been used for any stream. The most "
2138 "likely reason is either wrong type (e.g. a video option with "
2139 "no video streams) or that it is a private option of some encoder "
2140 "which was not actually used for any stream.\n", e->key,
2141 option->help ? option->help : "", nb_output_files - 1, filename);
2143 av_dict_free(&unused_opts);
2145 /* check filename in case of an image number is expected */
2146 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2147 if (!av_filename_number_test(oc->filename)) {
2148 print_error(oc->filename, AVERROR(EINVAL));
2153 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2154 av_log(NULL, AV_LOG_ERROR,
2155 "No input streams but output needs an input stream\n");
2159 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2160 /* test if it already exists to avoid losing precious files */
2161 assert_file_overwrite(filename);
2164 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2165 &oc->interrupt_callback,
2167 print_error(filename, err);
2170 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2171 assert_file_overwrite(filename);
2173 if (o->mux_preload) {
2174 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2176 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2179 for (i = 0; i < o->nb_metadata_map; i++) {
2181 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2183 if (in_file_index >= nb_input_files) {
2184 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2187 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2188 in_file_index >= 0 ?
2189 input_files[in_file_index]->ctx : NULL, o);
2193 if (o->chapters_input_file >= nb_input_files) {
2194 if (o->chapters_input_file == INT_MAX) {
2195 /* copy chapters from the first input file that has them*/
2196 o->chapters_input_file = -1;
2197 for (i = 0; i < nb_input_files; i++)
2198 if (input_files[i]->ctx->nb_chapters) {
2199 o->chapters_input_file = i;
2203 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2204 o->chapters_input_file);
2208 if (o->chapters_input_file >= 0)
2209 copy_chapters(input_files[o->chapters_input_file], of,
2210 !o->metadata_chapters_manual);
2212 /* copy global metadata by default */
2213 if (!o->metadata_global_manual && nb_input_files){
2214 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2215 AV_DICT_DONT_OVERWRITE);
2216 if(o->recording_time != INT64_MAX)
2217 av_dict_set(&oc->metadata, "duration", NULL, 0);
2218 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2220 if (!o->metadata_streams_manual)
2221 for (i = of->ost_index; i < nb_output_streams; i++) {
2223 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2225 ist = input_streams[output_streams[i]->source_index];
2226 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2227 if (!output_streams[i]->stream_copy) {
2228 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2229 if (ist->autorotate)
2230 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2234 /* process manually set metadata */
2235 for (i = 0; i < o->nb_metadata; i++) {
2238 const char *stream_spec;
2239 int index = 0, j, ret = 0;
2241 val = strchr(o->metadata[i].u.str, '=');
2243 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2244 o->metadata[i].u.str);
2249 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2251 for (j = 0; j < oc->nb_streams; j++) {
2252 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2253 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2254 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2255 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2256 ost->rotate_overridden = 1;
2268 if (index < 0 || index >= oc->nb_chapters) {
2269 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2272 m = &oc->chapters[index]->metadata;
2275 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2278 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2285 static int opt_target(void *optctx, const char *opt, const char *arg)
2287 OptionsContext *o = optctx;
2288 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2289 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2291 if (!strncmp(arg, "pal-", 4)) {
2294 } else if (!strncmp(arg, "ntsc-", 5)) {
2297 } else if (!strncmp(arg, "film-", 5)) {
2301 /* Try to determine PAL/NTSC by peeking in the input files */
2302 if (nb_input_files) {
2304 for (j = 0; j < nb_input_files; j++) {
2305 for (i = 0; i < input_files[j]->nb_streams; i++) {
2306 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2307 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2310 fr = c->time_base.den * 1000 / c->time_base.num;
2314 } else if ((fr == 29970) || (fr == 23976)) {
2319 if (norm != UNKNOWN)
2323 if (norm != UNKNOWN)
2324 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2327 if (norm == UNKNOWN) {
2328 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2329 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2330 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2334 if (!strcmp(arg, "vcd")) {
2335 opt_video_codec(o, "c:v", "mpeg1video");
2336 opt_audio_codec(o, "c:a", "mp2");
2337 parse_option(o, "f", "vcd", options);
2339 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2340 parse_option(o, "r", frame_rates[norm], options);
2341 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2343 opt_default(NULL, "b:v", "1150000");
2344 opt_default(NULL, "maxrate:v", "1150000");
2345 opt_default(NULL, "minrate:v", "1150000");
2346 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2348 opt_default(NULL, "b:a", "224000");
2349 parse_option(o, "ar", "44100", options);
2350 parse_option(o, "ac", "2", options);
2352 opt_default(NULL, "packetsize", "2324");
2353 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2355 /* We have to offset the PTS, so that it is consistent with the SCR.
2356 SCR starts at 36000, but the first two packs contain only padding
2357 and the first pack from the other stream, respectively, may also have
2358 been written before.
2359 So the real data starts at SCR 36000+3*1200. */
2360 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2361 } else if (!strcmp(arg, "svcd")) {
2363 opt_video_codec(o, "c:v", "mpeg2video");
2364 opt_audio_codec(o, "c:a", "mp2");
2365 parse_option(o, "f", "svcd", options);
2367 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2368 parse_option(o, "r", frame_rates[norm], options);
2369 parse_option(o, "pix_fmt", "yuv420p", options);
2370 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2372 opt_default(NULL, "b:v", "2040000");
2373 opt_default(NULL, "maxrate:v", "2516000");
2374 opt_default(NULL, "minrate:v", "0"); // 1145000;
2375 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2376 opt_default(NULL, "scan_offset", "1");
2378 opt_default(NULL, "b:a", "224000");
2379 parse_option(o, "ar", "44100", options);
2381 opt_default(NULL, "packetsize", "2324");
2383 } else if (!strcmp(arg, "dvd")) {
2385 opt_video_codec(o, "c:v", "mpeg2video");
2386 opt_audio_codec(o, "c:a", "ac3");
2387 parse_option(o, "f", "dvd", options);
2389 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2390 parse_option(o, "r", frame_rates[norm], options);
2391 parse_option(o, "pix_fmt", "yuv420p", options);
2392 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2394 opt_default(NULL, "b:v", "6000000");
2395 opt_default(NULL, "maxrate:v", "9000000");
2396 opt_default(NULL, "minrate:v", "0"); // 1500000;
2397 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2399 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2400 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2402 opt_default(NULL, "b:a", "448000");
2403 parse_option(o, "ar", "48000", options);
2405 } else if (!strncmp(arg, "dv", 2)) {
2407 parse_option(o, "f", "dv", options);
2409 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2410 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2411 norm == PAL ? "yuv420p" : "yuv411p", options);
2412 parse_option(o, "r", frame_rates[norm], options);
2414 parse_option(o, "ar", "48000", options);
2415 parse_option(o, "ac", "2", options);
2418 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2419 return AVERROR(EINVAL);
2422 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2423 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2428 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2430 av_free (vstats_filename);
2431 vstats_filename = av_strdup (arg);
2435 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2438 time_t today2 = time(NULL);
2439 struct tm *today = localtime(&today2);
2441 if (!today) { // maybe tomorrow
2442 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2446 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2448 return opt_vstats_file(NULL, opt, filename);
2451 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2453 OptionsContext *o = optctx;
2454 return parse_option(o, "frames:v", arg, options);
2457 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2459 OptionsContext *o = optctx;
2460 return parse_option(o, "frames:a", arg, options);
2463 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2465 OptionsContext *o = optctx;
2466 return parse_option(o, "frames:d", arg, options);
2469 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2472 AVDictionary *cbak = codec_opts;
2473 AVDictionary *fbak = format_opts;
2477 ret = opt_default(NULL, opt, arg);
2479 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2480 av_dict_copy(&o->g->format_opts, format_opts, 0);
2481 av_dict_free(&codec_opts);
2482 av_dict_free(&format_opts);
2489 static int opt_preset(void *optctx, const char *opt, const char *arg)
2491 OptionsContext *o = optctx;
2493 char filename[1000], line[1000], tmp_line[1000];
2494 const char *codec_name = NULL;
2498 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2500 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2501 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2502 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2504 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2508 while (fgets(line, sizeof(line), f)) {
2509 char *key = tmp_line, *value, *endptr;
2511 if (strcspn(line, "#\n\r") == 0)
2513 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2514 if (!av_strtok(key, "=", &value) ||
2515 !av_strtok(value, "\r\n", &endptr)) {
2516 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2519 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2521 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2522 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2523 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2524 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2525 else if (opt_default_new(o, key, value) < 0) {
2526 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2527 filename, line, key, value);
2537 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2539 OptionsContext *o = optctx;
2540 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2541 int ret = parse_option(o, s, arg, options);
2546 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2548 OptionsContext *o = optctx;
2550 if(!strcmp(opt, "ab")){
2551 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2553 } else if(!strcmp(opt, "b")){
2554 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2555 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2558 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2562 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2564 OptionsContext *o = optctx;
2567 if(!strcmp(opt, "qscale")){
2568 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2569 return parse_option(o, "q:v", arg, options);
2571 s = av_asprintf("q%s", opt + 6);
2572 ret = parse_option(o, s, arg, options);
2577 static int opt_profile(void *optctx, const char *opt, const char *arg)
2579 OptionsContext *o = optctx;
2580 if(!strcmp(opt, "profile")){
2581 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2582 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2585 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2589 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2591 OptionsContext *o = optctx;
2592 return parse_option(o, "filter:v", arg, options);
2595 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2597 OptionsContext *o = optctx;
2598 return parse_option(o, "filter:a", arg, options);
2601 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2603 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2604 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2605 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2606 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2608 if (video_sync_method == VSYNC_AUTO)
2609 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2613 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2615 OptionsContext *o = optctx;
2616 char *tcr = av_asprintf("timecode=%s", arg);
2617 int ret = parse_option(o, "metadata:g", tcr, options);
2619 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2624 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2626 OptionsContext *o = optctx;
2627 char layout_str[32];
2630 int ret, channels, ac_str_size;
2633 layout = av_get_channel_layout(arg);
2635 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2636 return AVERROR(EINVAL);
2638 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2639 ret = opt_default_new(o, opt, layout_str);
2643 /* set 'ac' option based on channel layout */
2644 channels = av_get_channel_layout_nb_channels(layout);
2645 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2646 stream_str = strchr(opt, ':');
2647 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2648 ac_str = av_mallocz(ac_str_size);
2650 return AVERROR(ENOMEM);
2651 av_strlcpy(ac_str, "ac", 3);
2653 av_strlcat(ac_str, stream_str, ac_str_size);
2654 ret = parse_option(o, ac_str, layout_str, options);
2660 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2662 OptionsContext *o = optctx;
2663 return parse_option(o, "q:a", arg, options);
2666 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2668 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2669 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2670 return AVERROR(ENOMEM);
2671 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2672 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2673 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2674 return AVERROR(ENOMEM);
2676 input_stream_potentially_available = 1;
2681 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2683 uint8_t *graph_desc = read_file(arg);
2685 return AVERROR(EINVAL);
2687 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2688 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2689 return AVERROR(ENOMEM);
2690 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2691 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2693 input_stream_potentially_available = 1;
2698 void show_help_default(const char *opt, const char *arg)
2700 /* per-file options have at least one of those set */
2701 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2702 int show_advanced = 0, show_avoptions = 0;
2705 if (!strcmp(opt, "long"))
2707 else if (!strcmp(opt, "full"))
2708 show_advanced = show_avoptions = 1;
2710 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2715 printf("Getting help:\n"
2716 " -h -- print basic options\n"
2717 " -h long -- print more options\n"
2718 " -h full -- print all options (including all format and codec specific options, very long)\n"
2719 " See man %s for detailed description of the options.\n"
2720 "\n", program_name);
2722 show_help_options(options, "Print help / information / capabilities:",
2725 show_help_options(options, "Global options (affect whole program "
2726 "instead of just one file:",
2727 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2729 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2730 per_file | OPT_EXIT, 0);
2732 show_help_options(options, "Per-file main options:", 0,
2733 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2734 OPT_EXIT, per_file);
2736 show_help_options(options, "Advanced per-file options:",
2737 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2739 show_help_options(options, "Video options:",
2740 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2742 show_help_options(options, "Advanced Video options:",
2743 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2745 show_help_options(options, "Audio options:",
2746 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2748 show_help_options(options, "Advanced Audio options:",
2749 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2750 show_help_options(options, "Subtitle options:",
2751 OPT_SUBTITLE, 0, 0);
2754 if (show_avoptions) {
2755 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2756 show_help_children(avcodec_get_class(), flags);
2757 show_help_children(avformat_get_class(), flags);
2759 show_help_children(sws_get_class(), flags);
2761 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2762 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2766 void show_usage(void)
2768 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2769 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2770 av_log(NULL, AV_LOG_INFO, "\n");
2778 static const OptionGroupDef groups[] = {
2779 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2780 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2783 static int open_files(OptionGroupList *l, const char *inout,
2784 int (*open_file)(OptionsContext*, const char*))
2788 for (i = 0; i < l->nb_groups; i++) {
2789 OptionGroup *g = &l->groups[i];
2795 ret = parse_optgroup(&o, g);
2797 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2798 "%s.\n", inout, g->arg);
2802 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2803 ret = open_file(&o, g->arg);
2806 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2810 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2816 int ffmpeg_parse_options(int argc, char **argv)
2818 OptionParseContext octx;
2822 memset(&octx, 0, sizeof(octx));
2824 /* split the commandline into an internal representation */
2825 ret = split_commandline(&octx, argc, argv, options, groups,
2826 FF_ARRAY_ELEMS(groups));
2828 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2832 /* apply global options */
2833 ret = parse_optgroup(NULL, &octx.global_opts);
2835 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2839 /* open input files */
2840 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2842 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2846 /* open output files */
2847 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2849 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2854 uninit_parse_context(&octx);
2856 av_strerror(ret, error, sizeof(error));
2857 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2862 static int opt_progress(void *optctx, const char *opt, const char *arg)
2864 AVIOContext *avio = NULL;
2867 if (!strcmp(arg, "-"))
2869 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2871 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2872 arg, av_err2str(ret));
2875 progress_avio = avio;
2879 #define OFFSET(x) offsetof(OptionsContext, x)
2880 const OptionDef options[] = {
2882 #include "cmdutils_common_opts.h"
2883 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2884 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2885 "force format", "fmt" },
2886 { "y", OPT_BOOL, { &file_overwrite },
2887 "overwrite output files" },
2888 { "n", OPT_BOOL, { &no_file_overwrite },
2889 "never overwrite output files" },
2890 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2891 "Ignore unknown stream types" },
2892 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2893 "Copy unknown stream types" },
2894 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2895 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2896 "codec name", "codec" },
2897 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2898 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2899 "codec name", "codec" },
2900 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2901 OPT_OUTPUT, { .off = OFFSET(presets) },
2902 "preset name", "preset" },
2903 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2904 OPT_OUTPUT, { .func_arg = opt_map },
2905 "set input stream mapping",
2906 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2907 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2908 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2909 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2910 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2911 "set metadata information of outfile from infile",
2912 "outfile[,metadata]:infile[,metadata]" },
2913 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2914 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2915 "set chapters mapping", "input_file_index" },
2916 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2917 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2918 "record or transcode \"duration\" seconds of audio/video",
2920 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2921 "record or transcode stop time", "time_stop" },
2922 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2923 "set the limit file size in bytes", "limit_size" },
2924 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2925 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2926 "set the start time offset", "time_off" },
2927 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2928 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
2929 "enable/disable seeking by timestamp with -ss" },
2930 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2931 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2932 "enable/disable accurate seeking with -ss" },
2933 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2934 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2935 "set the input ts offset", "time_off" },
2936 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2937 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2938 "set the input ts scale", "scale" },
2939 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
2940 "set the recording timestamp ('now' to set the current time)", "time" },
2941 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2942 "add metadata", "string=string" },
2943 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2944 OPT_OUTPUT, { .func_arg = opt_data_frames },
2945 "set the number of data frames to output", "number" },
2946 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2947 "add timings for benchmarking" },
2948 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2949 "add timings for each task" },
2950 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2951 "write program-readable progress information", "url" },
2952 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2953 "enable or disable interaction on standard input" },
2954 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2955 "set max runtime in seconds", "limit" },
2956 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2957 "dump each input packet" },
2958 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2959 "when dumping packets, also dump the payload" },
2960 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2961 OPT_INPUT, { .off = OFFSET(rate_emu) },
2962 "read input at native frame rate", "" },
2963 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2964 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2965 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2966 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2967 "video sync method", "" },
2968 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2969 "frame drop threshold", "" },
2970 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2971 "audio sync method", "" },
2972 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2973 "audio drift threshold", "threshold" },
2974 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2975 "copy timestamps" },
2976 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2977 "shift input timestamps to start at 0 when using copyts" },
2978 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2979 "copy input stream time base when stream copying", "mode" },
2980 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2981 OPT_OUTPUT, { .off = OFFSET(shortest) },
2982 "finish encoding within shortest input" },
2983 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2984 OPT_OUTPUT, { .off = OFFSET(apad) },
2986 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2987 "timestamp discontinuity delta threshold", "threshold" },
2988 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2989 "timestamp error delta threshold", "threshold" },
2990 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2991 "exit on error", "error" },
2992 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2993 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2994 "copy initial non-keyframes" },
2995 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2996 "copy or discard frames before start time" },
2997 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2998 "set the number of frames to output", "number" },
2999 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3000 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3001 "force codec tag/fourcc", "fourcc/tag" },
3002 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3003 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3004 "use fixed quality scale (VBR)", "q" },
3005 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3006 OPT_OUTPUT, { .func_arg = opt_qscale },
3007 "use fixed quality scale (VBR)", "q" },
3008 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3009 "set profile", "profile" },
3010 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3011 "set stream filtergraph", "filter_graph" },
3012 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3013 "read stream filtergraph description from a file", "filename" },
3014 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3015 "reinit filtergraph on input parameter changes", "" },
3016 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3017 "create a complex filtergraph", "graph_description" },
3018 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3019 "create a complex filtergraph", "graph_description" },
3020 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3021 "read complex filtergraph description from a file", "filename" },
3022 { "stats", OPT_BOOL, { &print_stats },
3023 "print progress report during encoding", },
3024 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3025 OPT_OUTPUT, { .func_arg = opt_attach },
3026 "add an attachment to the output file", "filename" },
3027 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3028 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3029 "extract an attachment into a file", "filename" },
3030 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3031 "print timestamp debugging info" },
3032 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3033 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3034 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3035 OPT_INPUT, { .off = OFFSET(discard) },
3037 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3038 OPT_OUTPUT, { .off = OFFSET(disposition) },
3039 "disposition", "" },
3040 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3041 { .off = OFFSET(thread_queue_size) },
3042 "set the maximum number of queued packets from the demuxer" },
3045 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3046 "set the number of video frames to output", "number" },
3047 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3048 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3049 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3050 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3051 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3052 "set frame size (WxH or abbreviation)", "size" },
3053 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3054 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3055 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3056 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3057 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3058 "set pixel format", "format" },
3059 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3060 "set the number of bits per raw sample", "number" },
3061 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3062 "deprecated use -g 1" },
3063 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3065 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3066 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3067 "rate control override for specific intervals", "override" },
3068 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3069 OPT_OUTPUT, { .func_arg = opt_video_codec },
3070 "force video codec ('copy' to copy stream)", "codec" },
3071 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3073 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3075 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3076 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3077 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3078 "select the pass number (1 to 3)", "n" },
3079 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3080 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3081 "select two pass log file name prefix", "prefix" },
3082 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3083 "this option is deprecated, use the yadif filter instead" },
3084 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3085 "calculate PSNR of compressed frames" },
3086 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3087 "dump video coding statistics to file" },
3088 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3089 "dump video coding statistics to file", "file" },
3090 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3091 "set video filters", "filter_graph" },
3092 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3093 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3094 "specify intra matrix coeffs", "matrix" },
3095 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3096 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3097 "specify inter matrix coeffs", "matrix" },
3098 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3099 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3100 "specify intra matrix coeffs", "matrix" },
3101 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3102 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3103 "top=1/bottom=0/auto=-1 field first", "" },
3104 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3105 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3106 "force video tag/fourcc", "fourcc/tag" },
3107 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3108 "show QP histogram" },
3109 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3110 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3111 "force the selected framerate, disable the best supported framerate selection" },
3112 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3113 OPT_OUTPUT, { .func_arg = opt_streamid },
3114 "set the value of an outfile streamid", "streamIndex:value" },
3115 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3116 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3117 "force key frames at specified timestamps", "timestamps" },
3118 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3119 "audio bitrate (please use -b:a)", "bitrate" },
3120 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3121 "video bitrate (please use -b:v)", "bitrate" },
3122 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3123 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3124 "use HW accelerated decoding", "hwaccel name" },
3125 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3126 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3127 "select a device for HW acceleration" "devicename" },
3129 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3131 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3132 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3133 "automatically insert correct rotate filters" },
3136 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3137 "set the number of audio frames to output", "number" },
3138 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3139 "set audio quality (codec-specific)", "quality", },
3140 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3141 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3142 "set audio sampling rate (in Hz)", "rate" },
3143 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3144 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3145 "set number of audio channels", "channels" },
3146 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3148 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3149 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3150 "force audio codec ('copy' to copy stream)", "codec" },
3151 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3152 OPT_OUTPUT, { .func_arg = opt_old2new },
3153 "force audio tag/fourcc", "fourcc/tag" },
3154 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3155 "change audio volume (256=normal)" , "volume" },
3156 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3157 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3158 "set sample format", "format" },
3159 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3160 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3161 "set channel layout", "layout" },
3162 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3163 "set audio filters", "filter_graph" },
3164 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3165 "set the maximum number of channels to try to guess the channel layout" },
3167 /* subtitle options */
3168 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3169 "disable subtitle" },
3170 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3171 "force subtitle codec ('copy' to copy stream)", "codec" },
3172 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3173 , "force subtitle tag/fourcc", "fourcc/tag" },
3174 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3175 "fix subtitles duration" },
3176 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3177 "set canvas size (WxH or abbreviation)", "size" },
3180 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3181 "deprecated, use -channel", "channel" },
3182 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3183 "deprecated, use -standard", "standard" },
3184 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3187 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3188 "set the maximum demux-decode delay", "seconds" },
3189 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3190 "set the initial demux-decode delay", "seconds" },
3191 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3192 "override the options from ffserver", "" },
3193 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3194 "specify a file in which to print sdp information", "file" },
3196 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3197 "A comma-separated list of bitstream filters", "bitstream_filters" },
3198 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3199 "deprecated", "audio bitstream_filters" },
3200 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3201 "deprecated", "video bitstream_filters" },
3203 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3204 "set the audio options to the indicated preset", "preset" },
3205 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3206 "set the video options to the indicated preset", "preset" },
3207 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3208 "set the subtitle options to the indicated preset", "preset" },
3209 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3210 "set options from indicated preset file", "filename" },
3211 /* data codec support */
3212 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3213 "force data codec ('copy' to copy stream)", "codec" },
3214 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },