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 DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
69 #if CONFIG_VIDEOTOOLBOX
70 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
73 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
76 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
80 AVBufferRef *hw_device_ctx;
81 HWDevice *filter_hw_device;
83 char *vstats_filename;
86 float audio_drift_threshold = 0.1;
87 float dts_delta_threshold = 10;
88 float dts_error_threshold = 3600*30;
90 int audio_volume = 256;
91 int audio_sync_method = 0;
92 int video_sync_method = VSYNC_AUTO;
93 float frame_drop_threshold = 0;
94 int do_deinterlace = 0;
96 int do_benchmark_all = 0;
100 int start_at_zero = 0;
103 int exit_on_error = 0;
104 int abort_on_flags = 0;
105 int print_stats = -1;
107 int stdin_interaction = 1;
108 int frame_bits_per_raw_sample = 0;
109 float max_error_rate = 2.0/3;
110 int filter_nbthreads = 0;
111 int filter_complex_nbthreads = 0;
112 int vstats_version = 2;
115 static int intra_only = 0;
116 static int file_overwrite = 0;
117 static int no_file_overwrite = 0;
118 static int do_psnr = 0;
119 static int input_sync;
120 static int input_stream_potentially_available = 0;
121 static int ignore_unknown_streams = 0;
122 static int copy_unknown_streams = 0;
123 static int find_stream_info = 1;
125 static void uninit_options(OptionsContext *o)
127 const OptionDef *po = options;
130 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132 void *dst = (uint8_t*)o + po->u.off;
134 if (po->flags & OPT_SPEC) {
135 SpecifierOpt **so = dst;
136 int i, *count = (int*)(so + 1);
137 for (i = 0; i < *count; i++) {
138 av_freep(&(*so)[i].specifier);
139 if (po->flags & OPT_STRING)
140 av_freep(&(*so)[i].u.str);
144 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
149 for (i = 0; i < o->nb_stream_maps; i++)
150 av_freep(&o->stream_maps[i].linklabel);
151 av_freep(&o->stream_maps);
152 av_freep(&o->audio_channel_maps);
153 av_freep(&o->streamid_map);
154 av_freep(&o->attachments);
157 static void init_options(OptionsContext *o)
159 memset(o, 0, sizeof(*o));
161 o->stop_time = INT64_MAX;
162 o->mux_max_delay = 0.7;
163 o->start_time = AV_NOPTS_VALUE;
164 o->start_time_eof = AV_NOPTS_VALUE;
165 o->recording_time = INT64_MAX;
166 o->limit_filesize = UINT64_MAX;
167 o->chapters_input_file = INT_MAX;
168 o->accurate_seek = 1;
171 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
176 printf("Hardware acceleration methods:\n");
177 while ((type = av_hwdevice_iterate_types(type)) !=
178 AV_HWDEVICE_TYPE_NONE)
179 printf("%s\n", av_hwdevice_get_type_name(type));
180 for (i = 0; hwaccels[i].name; i++)
181 printf("%s\n", hwaccels[i].name);
186 /* return a copy of the input with the stream specifiers removed from the keys */
187 static AVDictionary *strip_specifiers(AVDictionary *dict)
189 AVDictionaryEntry *e = NULL;
190 AVDictionary *ret = NULL;
192 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
193 char *p = strchr(e->key, ':');
197 av_dict_set(&ret, e->key, e->value, 0);
204 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206 static const AVOption opts[] = {
207 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
208 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
211 static const AVClass class = {
213 .item_name = av_default_item_name,
215 .version = LIBAVUTIL_VERSION_INT,
217 const AVClass *pclass = &class;
219 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
222 static int opt_sameq(void *optctx, const char *opt, const char *arg)
224 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
225 "If you are looking for an option to preserve the quality (which is not "
226 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228 return AVERROR(EINVAL);
231 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
234 return opt_default(optctx, "channel", arg);
237 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
240 return opt_default(optctx, "standard", arg);
243 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245 OptionsContext *o = optctx;
246 return parse_option(o, "codec:a", arg, options);
249 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:v", arg, options);
255 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:s", arg, options);
261 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:d", arg, options);
267 static int opt_map(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
271 int i, negative = 0, file_idx;
272 int sync_file_idx = -1, sync_stream_idx = 0;
281 map = av_strdup(arg);
283 return AVERROR(ENOMEM);
285 /* parse sync stream first, just pick first matching stream */
286 if (sync = strchr(map, ',')) {
288 sync_file_idx = strtol(sync + 1, &sync, 0);
289 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
290 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
295 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
296 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
297 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
301 if (i == input_files[sync_file_idx]->nb_streams) {
302 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
303 "match any streams.\n", arg);
310 /* this mapping refers to lavfi output */
311 const char *c = map + 1;
312 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
313 m = &o->stream_maps[o->nb_stream_maps - 1];
314 m->linklabel = av_get_token(&c, "]");
316 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
320 if (allow_unused = strchr(map, '?'))
322 file_idx = strtol(map, &p, 0);
323 if (file_idx >= nb_input_files || file_idx < 0) {
324 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
328 /* disable some already defined maps */
329 for (i = 0; i < o->nb_stream_maps; i++) {
330 m = &o->stream_maps[i];
331 if (file_idx == m->file_index &&
332 check_stream_specifier(input_files[m->file_index]->ctx,
333 input_files[m->file_index]->ctx->streams[m->stream_index],
334 *p == ':' ? p + 1 : p) > 0)
338 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
339 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
340 *p == ':' ? p + 1 : p) <= 0)
342 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
343 m = &o->stream_maps[o->nb_stream_maps - 1];
345 m->file_index = file_idx;
348 if (sync_file_idx >= 0) {
349 m->sync_file_index = sync_file_idx;
350 m->sync_stream_index = sync_stream_idx;
352 m->sync_file_index = file_idx;
353 m->sync_stream_index = i;
360 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
362 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
363 "To ignore this, add a trailing '?' to the map.\n", arg);
372 static int opt_attach(void *optctx, const char *opt, const char *arg)
374 OptionsContext *o = optctx;
375 GROW_ARRAY(o->attachments, o->nb_attachments);
376 o->attachments[o->nb_attachments - 1] = arg;
380 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
382 OptionsContext *o = optctx;
388 mapchan = av_strdup(arg);
390 return AVERROR(ENOMEM);
392 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
393 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
395 /* muted channel syntax */
396 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
397 if ((n == 1 || n == 3) && m->channel_idx == -1) {
398 m->file_idx = m->stream_idx = -1;
400 m->ofile_idx = m->ostream_idx = -1;
406 n = sscanf(arg, "%d.%d.%d:%d.%d",
407 &m->file_idx, &m->stream_idx, &m->channel_idx,
408 &m->ofile_idx, &m->ostream_idx);
410 if (n != 3 && n != 5) {
411 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
412 "[file.stream.channel|-1][:syncfile:syncstream]\n");
416 if (n != 5) // only file.stream.channel specified
417 m->ofile_idx = m->ostream_idx = -1;
420 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425 if (m->stream_idx < 0 ||
426 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
427 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
428 m->file_idx, m->stream_idx);
431 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
432 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
433 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
434 m->file_idx, m->stream_idx);
437 /* allow trailing ? to map_channel */
438 if (allow_unused = strchr(mapchan, '?'))
440 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
442 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
443 m->file_idx, m->stream_idx, m->channel_idx);
445 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
446 "To ignore this, add a trailing '?' to the map_channel.\n",
447 m->file_idx, m->stream_idx, m->channel_idx);
456 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
458 av_free(sdp_filename);
459 sdp_filename = av_strdup(arg);
464 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
467 const char *prefix = "vaapi:";
470 tmp = av_asprintf("%s%s", prefix, arg);
472 return AVERROR(ENOMEM);
473 err = hw_device_init_from_string(tmp, &dev);
477 hw_device_ctx = av_buffer_ref(dev->device_ref);
479 return AVERROR(ENOMEM);
484 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
486 if (!strcmp(arg, "list")) {
487 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
488 printf("Supported hardware device types:\n");
489 while ((type = av_hwdevice_iterate_types(type)) !=
490 AV_HWDEVICE_TYPE_NONE)
491 printf("%s\n", av_hwdevice_get_type_name(type));
495 return hw_device_init_from_string(arg, NULL);
499 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
501 if (filter_hw_device) {
502 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
503 return AVERROR(EINVAL);
505 filter_hw_device = hw_device_get_by_name(arg);
506 if (!filter_hw_device) {
507 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
508 return AVERROR(EINVAL);
514 * Parse a metadata specifier passed as 'arg' parameter.
515 * @param arg metadata string to parse
516 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
517 * @param index for type c/p, chapter/program index is written here
518 * @param stream_spec for type s, the stream specifier is written here
520 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
528 if (*(++arg) && *arg != ':') {
529 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
532 *stream_spec = *arg == ':' ? arg + 1 : "";
537 *index = strtol(++arg, NULL, 0);
540 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
547 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
549 AVDictionary **meta_in = NULL;
550 AVDictionary **meta_out = NULL;
552 char type_in, type_out;
553 const char *istream_spec = NULL, *ostream_spec = NULL;
554 int idx_in = 0, idx_out = 0;
556 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
557 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
560 if (type_out == 'g' || !*outspec)
561 o->metadata_global_manual = 1;
562 if (type_out == 's' || !*outspec)
563 o->metadata_streams_manual = 1;
564 if (type_out == 'c' || !*outspec)
565 o->metadata_chapters_manual = 1;
569 if (type_in == 'g' || type_out == 'g')
570 o->metadata_global_manual = 1;
571 if (type_in == 's' || type_out == 's')
572 o->metadata_streams_manual = 1;
573 if (type_in == 'c' || type_out == 'c')
574 o->metadata_chapters_manual = 1;
576 /* ic is NULL when just disabling automatic mappings */
580 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
581 if ((index) < 0 || (index) >= (nb_elems)) {\
582 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
587 #define SET_DICT(type, meta, context, index)\
590 meta = &context->metadata;\
593 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
594 meta = &context->chapters[index]->metadata;\
597 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
598 meta = &context->programs[index]->metadata;\
601 break; /* handled separately below */ \
602 default: av_assert0(0);\
605 SET_DICT(type_in, meta_in, ic, idx_in);
606 SET_DICT(type_out, meta_out, oc, idx_out);
608 /* for input streams choose first matching stream */
609 if (type_in == 's') {
610 for (i = 0; i < ic->nb_streams; i++) {
611 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
612 meta_in = &ic->streams[i]->metadata;
618 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
623 if (type_out == 's') {
624 for (i = 0; i < oc->nb_streams; i++) {
625 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
626 meta_out = &oc->streams[i]->metadata;
627 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
632 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
637 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
639 OptionsContext *o = optctx;
641 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
642 struct tm time = *gmtime((time_t*)&recording_timestamp);
643 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
645 parse_option(o, "metadata", buf, options);
647 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
648 "tag instead.\n", opt);
652 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
654 const AVCodecDescriptor *desc;
655 const char *codec_string = encoder ? "encoder" : "decoder";
659 avcodec_find_encoder_by_name(name) :
660 avcodec_find_decoder_by_name(name);
662 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
663 codec = encoder ? avcodec_find_encoder(desc->id) :
664 avcodec_find_decoder(desc->id);
666 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
667 codec_string, codec->name, desc->name);
671 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
674 if (codec->type != type) {
675 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
681 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
683 char *codec_name = NULL;
685 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
687 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
688 st->codecpar->codec_id = codec->id;
691 return avcodec_find_decoder(st->codecpar->codec_id);
694 /* Add all the streams from the given input file to the global
695 * list of input streams. */
696 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
700 for (i = 0; i < ic->nb_streams; i++) {
701 AVStream *st = ic->streams[i];
702 AVCodecParameters *par = st->codecpar;
703 InputStream *ist = av_mallocz(sizeof(*ist));
704 char *framerate = NULL, *hwaccel_device = NULL;
705 const char *hwaccel = NULL;
706 char *hwaccel_output_format = NULL;
707 char *codec_tag = NULL;
709 char *discard_str = NULL;
710 const AVClass *cc = avcodec_get_class();
711 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
716 GROW_ARRAY(input_streams, nb_input_streams);
717 input_streams[nb_input_streams - 1] = ist;
720 ist->file_index = nb_input_files;
722 st->discard = AVDISCARD_ALL;
724 ist->min_pts = INT64_MAX;
725 ist->max_pts = INT64_MIN;
728 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
731 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
733 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
735 uint32_t tag = strtol(codec_tag, &next, 0);
737 tag = AV_RL32(codec_tag);
738 st->codecpar->codec_tag = tag;
741 ist->dec = choose_decoder(o, ic, st);
742 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
744 ist->reinit_filters = -1;
745 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
747 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
748 ist->user_set_discard = AVDISCARD_NONE;
749 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
750 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
755 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
757 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
759 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
763 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
765 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
770 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
772 switch (par->codec_type) {
773 case AVMEDIA_TYPE_VIDEO:
775 ist->dec = avcodec_find_decoder(par->codec_id);
777 if (st->codec->lowres) {
778 ist->dec_ctx->lowres = st->codec->lowres;
779 ist->dec_ctx->width = st->codec->width;
780 ist->dec_ctx->height = st->codec->height;
781 ist->dec_ctx->coded_width = st->codec->coded_width;
782 ist->dec_ctx->coded_height = st->codec->coded_height;
786 // avformat_find_stream_info() doesn't set this for us anymore.
787 ist->dec_ctx->framerate = st->avg_frame_rate;
789 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
790 if (framerate && av_parse_video_rate(&ist->framerate,
792 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
797 ist->top_field_first = -1;
798 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
800 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
802 // The NVDEC hwaccels use a CUDA device, so remap the name here.
803 if (!strcmp(hwaccel, "nvdec"))
806 if (!strcmp(hwaccel, "none"))
807 ist->hwaccel_id = HWACCEL_NONE;
808 else if (!strcmp(hwaccel, "auto"))
809 ist->hwaccel_id = HWACCEL_AUTO;
811 enum AVHWDeviceType type;
813 for (i = 0; hwaccels[i].name; i++) {
814 if (!strcmp(hwaccels[i].name, hwaccel)) {
815 ist->hwaccel_id = hwaccels[i].id;
820 if (!ist->hwaccel_id) {
821 type = av_hwdevice_find_type_by_name(hwaccel);
822 if (type != AV_HWDEVICE_TYPE_NONE) {
823 ist->hwaccel_id = HWACCEL_GENERIC;
824 ist->hwaccel_device_type = type;
828 if (!ist->hwaccel_id) {
829 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
831 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
832 type = AV_HWDEVICE_TYPE_NONE;
833 while ((type = av_hwdevice_iterate_types(type)) !=
834 AV_HWDEVICE_TYPE_NONE)
835 av_log(NULL, AV_LOG_FATAL, "%s ",
836 av_hwdevice_get_type_name(type));
837 for (i = 0; hwaccels[i].name; i++)
838 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
839 av_log(NULL, AV_LOG_FATAL, "\n");
845 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
846 if (hwaccel_device) {
847 ist->hwaccel_device = av_strdup(hwaccel_device);
848 if (!ist->hwaccel_device)
852 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
853 hwaccel_output_format, ic, st);
854 if (hwaccel_output_format) {
855 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
856 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
857 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
858 "format: %s", hwaccel_output_format);
861 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
864 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
867 case AVMEDIA_TYPE_AUDIO:
868 ist->guess_layout_max = INT_MAX;
869 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
870 guess_input_channel_layout(ist);
872 case AVMEDIA_TYPE_DATA:
873 case AVMEDIA_TYPE_SUBTITLE: {
874 char *canvas_size = NULL;
876 ist->dec = avcodec_find_decoder(par->codec_id);
877 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
878 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
880 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
881 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
886 case AVMEDIA_TYPE_ATTACHMENT:
887 case AVMEDIA_TYPE_UNKNOWN:
893 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
895 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
901 static void assert_file_overwrite(const char *filename)
903 if (file_overwrite && no_file_overwrite) {
904 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
908 if (!file_overwrite) {
909 const char *proto_name = avio_find_protocol_name(filename);
910 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
911 if (stdin_interaction && !no_file_overwrite) {
912 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
915 signal(SIGINT, SIG_DFL);
917 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
923 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
930 static void dump_attachment(AVStream *st, const char *filename)
933 AVIOContext *out = NULL;
934 AVDictionaryEntry *e;
936 if (!st->codecpar->extradata_size) {
937 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
938 nb_input_files - 1, st->index);
941 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
944 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
945 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
949 assert_file_overwrite(filename);
951 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
952 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
957 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
962 static int open_input_file(OptionsContext *o, const char *filename)
966 AVInputFormat *file_iformat = NULL;
969 AVDictionary *unused_opts = NULL;
970 AVDictionaryEntry *e = NULL;
971 char * video_codec_name = NULL;
972 char * audio_codec_name = NULL;
973 char *subtitle_codec_name = NULL;
974 char * data_codec_name = NULL;
975 int scan_all_pmts_set = 0;
977 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
978 o->stop_time = INT64_MAX;
979 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
982 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
983 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
984 if (o->stop_time <= start_time) {
985 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
988 o->recording_time = o->stop_time - start_time;
993 if (!(file_iformat = av_find_input_format(o->format))) {
994 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
999 if (!strcmp(filename, "-"))
1002 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1003 strcmp(filename, "/dev/stdin");
1005 /* get default parameters from command line */
1006 ic = avformat_alloc_context();
1008 print_error(filename, AVERROR(ENOMEM));
1011 if (o->nb_audio_sample_rate) {
1012 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1014 if (o->nb_audio_channels) {
1015 /* because we set audio_channels based on both the "ac" and
1016 * "channel_layout" options, we need to check that the specified
1017 * demuxer actually has the "channels" option before setting it */
1018 if (file_iformat && file_iformat->priv_class &&
1019 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1020 AV_OPT_SEARCH_FAKE_OBJ)) {
1021 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1024 if (o->nb_frame_rates) {
1025 /* set the format-level framerate option;
1026 * this is important for video grabbers, e.g. x11 */
1027 if (file_iformat && file_iformat->priv_class &&
1028 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1029 AV_OPT_SEARCH_FAKE_OBJ)) {
1030 av_dict_set(&o->g->format_opts, "framerate",
1031 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1034 if (o->nb_frame_sizes) {
1035 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1037 if (o->nb_frame_pix_fmts)
1038 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1040 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1041 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1042 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1043 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1045 if (video_codec_name)
1046 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1047 if (audio_codec_name)
1048 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1049 if (subtitle_codec_name)
1050 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1051 if (data_codec_name)
1052 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1054 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1055 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1056 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1057 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1059 ic->flags |= AVFMT_FLAG_NONBLOCK;
1061 ic->flags |= AVFMT_FLAG_BITEXACT;
1062 ic->interrupt_callback = int_cb;
1064 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1065 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1066 scan_all_pmts_set = 1;
1068 /* open the input file with generic avformat function */
1069 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1071 print_error(filename, err);
1072 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1073 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1076 if (scan_all_pmts_set)
1077 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1078 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1079 assert_avoptions(o->g->format_opts);
1081 /* apply forced codec ids */
1082 for (i = 0; i < ic->nb_streams; i++)
1083 choose_decoder(o, ic, ic->streams[i]);
1085 if (find_stream_info) {
1086 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1087 int orig_nb_streams = ic->nb_streams;
1089 /* If not enough info to get the stream parameters, we decode the
1090 first frames to get it. (used in mpeg case for example) */
1091 ret = avformat_find_stream_info(ic, opts);
1093 for (i = 0; i < orig_nb_streams; i++)
1094 av_dict_free(&opts[i]);
1098 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1099 if (ic->nb_streams == 0) {
1100 avformat_close_input(&ic);
1106 if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1107 av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1108 o->start_time_eof = AV_NOPTS_VALUE;
1111 if (o->start_time_eof != AV_NOPTS_VALUE) {
1112 if (o->start_time_eof >= 0) {
1113 av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1116 if (ic->duration > 0) {
1117 o->start_time = o->start_time_eof + ic->duration;
1118 if (o->start_time < 0) {
1119 av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1120 o->start_time = AV_NOPTS_VALUE;
1123 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1125 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1126 /* add the stream start time */
1127 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1128 timestamp += ic->start_time;
1130 /* if seeking requested, we execute it */
1131 if (o->start_time != AV_NOPTS_VALUE) {
1132 int64_t seek_timestamp = timestamp;
1134 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1135 int dts_heuristic = 0;
1136 for (i=0; i<ic->nb_streams; i++) {
1137 const AVCodecParameters *par = ic->streams[i]->codecpar;
1138 if (par->video_delay)
1141 if (dts_heuristic) {
1142 seek_timestamp -= 3*AV_TIME_BASE / 23;
1145 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1147 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1148 filename, (double)timestamp / AV_TIME_BASE);
1152 /* update the current parameters so that they match the one of the input stream */
1153 add_input_streams(o, ic);
1155 /* dump the file content */
1156 av_dump_format(ic, nb_input_files, filename, 0);
1158 GROW_ARRAY(input_files, nb_input_files);
1159 f = av_mallocz(sizeof(*f));
1162 input_files[nb_input_files - 1] = f;
1165 f->ist_index = nb_input_streams - ic->nb_streams;
1166 f->start_time = o->start_time;
1167 f->recording_time = o->recording_time;
1168 f->input_ts_offset = o->input_ts_offset;
1169 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1170 f->nb_streams = ic->nb_streams;
1171 f->rate_emu = o->rate_emu;
1172 f->accurate_seek = o->accurate_seek;
1175 f->time_base = (AVRational){ 1, 1 };
1177 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1180 /* check if all codec options have been used */
1181 unused_opts = strip_specifiers(o->g->codec_opts);
1182 for (i = f->ist_index; i < nb_input_streams; i++) {
1184 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1185 AV_DICT_IGNORE_SUFFIX)))
1186 av_dict_set(&unused_opts, e->key, NULL, 0);
1190 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1191 const AVClass *class = avcodec_get_class();
1192 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1193 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1194 const AVClass *fclass = avformat_get_class();
1195 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1196 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1197 if (!option || foption)
1201 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1202 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1203 "input file #%d (%s) is not a decoding option.\n", e->key,
1204 option->help ? option->help : "", nb_input_files - 1,
1209 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1210 "input file #%d (%s) has not been used for any stream. The most "
1211 "likely reason is either wrong type (e.g. a video option with "
1212 "no video streams) or that it is a private option of some decoder "
1213 "which was not actually used for any stream.\n", e->key,
1214 option->help ? option->help : "", nb_input_files - 1, filename);
1216 av_dict_free(&unused_opts);
1218 for (i = 0; i < o->nb_dump_attachment; i++) {
1221 for (j = 0; j < ic->nb_streams; j++) {
1222 AVStream *st = ic->streams[j];
1224 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1225 dump_attachment(st, o->dump_attachment[i].u.str);
1229 input_stream_potentially_available = 1;
1234 static uint8_t *get_line(AVIOContext *s)
1240 if (avio_open_dyn_buf(&line) < 0) {
1241 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1245 while ((c = avio_r8(s)) && c != '\n')
1248 avio_close_dyn_buf(line, &buf);
1253 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1256 char filename[1000];
1257 const char *base[3] = { getenv("AVCONV_DATADIR"),
1262 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1266 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1267 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1268 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1271 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1272 i != 1 ? "" : "/.avconv", preset_name);
1273 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1279 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1281 enum AVMediaType type = ost->st->codecpar->codec_type;
1282 char *codec_name = NULL;
1284 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1285 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1287 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1288 NULL, ost->st->codecpar->codec_type);
1289 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1291 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1292 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1293 "probably disabled. Please choose an encoder manually.\n",
1294 ost->file_index, ost->index, s->oformat->name,
1295 avcodec_get_name(ost->st->codecpar->codec_id));
1296 return AVERROR_ENCODER_NOT_FOUND;
1298 } else if (!strcmp(codec_name, "copy"))
1299 ost->stream_copy = 1;
1301 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1302 ost->st->codecpar->codec_id = ost->enc->id;
1304 ost->encoding_needed = !ost->stream_copy;
1306 /* no encoding supported for other media types */
1307 ost->stream_copy = 1;
1308 ost->encoding_needed = 0;
1314 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1317 AVStream *st = avformat_new_stream(oc, NULL);
1318 int idx = oc->nb_streams - 1, ret = 0;
1319 const char *bsfs = NULL, *time_base = NULL;
1320 char *next, *codec_tag = NULL;
1325 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1329 if (oc->nb_streams - 1 < o->nb_streamid_map)
1330 st->id = o->streamid_map[oc->nb_streams - 1];
1332 GROW_ARRAY(output_streams, nb_output_streams);
1333 if (!(ost = av_mallocz(sizeof(*ost))))
1335 output_streams[nb_output_streams - 1] = ost;
1337 ost->file_index = nb_output_files - 1;
1340 ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1341 st->codecpar->codec_type = type;
1343 ret = choose_encoder(o, oc, ost);
1345 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1346 "%d:%d\n", ost->file_index, ost->index);
1350 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1351 if (!ost->enc_ctx) {
1352 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1355 ost->enc_ctx->codec_type = type;
1357 ost->ref_par = avcodec_parameters_alloc();
1358 if (!ost->ref_par) {
1359 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1364 AVIOContext *s = NULL;
1365 char *buf = NULL, *arg = NULL, *preset = NULL;
1367 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1369 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1370 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1373 if (!buf[0] || buf[0] == '#') {
1377 if (!(arg = strchr(buf, '='))) {
1378 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1382 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1384 } while (!s->eof_reached);
1388 av_log(NULL, AV_LOG_FATAL,
1389 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1390 preset, ost->file_index, ost->index);
1394 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1399 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1401 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1404 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1405 q.num <= 0 || q.den <= 0) {
1406 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1412 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1415 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1417 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1420 ost->enc_timebase = q;
1423 ost->max_frames = INT64_MAX;
1424 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1425 for (i = 0; i<o->nb_max_frames; i++) {
1426 char *p = o->max_frames[i].specifier;
1427 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1428 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1433 ost->copy_prior_start = -1;
1434 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1436 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1437 while (bsfs && *bsfs) {
1438 const AVBitStreamFilter *filter;
1439 char *bsf, *bsf_options_str, *bsf_name;
1441 bsf = av_get_token(&bsfs, ",");
1444 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1448 filter = av_bsf_get_by_name(bsf_name);
1450 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1454 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1455 ost->nb_bitstream_filters + 1,
1456 sizeof(*ost->bsf_ctx));
1460 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1462 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1466 ost->nb_bitstream_filters++;
1468 if (bsf_options_str && filter->priv_class) {
1469 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1470 const char * shorthand[2] = {NULL};
1473 shorthand[0] = opt->name;
1475 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1477 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1487 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1489 uint32_t tag = strtol(codec_tag, &next, 0);
1491 tag = AV_RL32(codec_tag);
1492 ost->st->codecpar->codec_tag =
1493 ost->enc_ctx->codec_tag = tag;
1496 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1498 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1499 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1502 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1503 ost->disposition = av_strdup(ost->disposition);
1505 ost->max_muxing_queue_size = 128;
1506 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1507 ost->max_muxing_queue_size *= sizeof(AVPacket);
1509 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1510 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1512 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1514 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1515 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1516 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1518 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1520 ost->source_index = source_index;
1521 if (source_index >= 0) {
1522 ost->sync_ist = input_streams[source_index];
1523 input_streams[source_index]->discard = 0;
1524 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1526 ost->last_mux_dts = AV_NOPTS_VALUE;
1528 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1529 if (!ost->muxing_queue)
1535 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1538 const char *p = str;
1545 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1552 /* read file contents into a string */
1553 static uint8_t *read_file(const char *filename)
1555 AVIOContext *pb = NULL;
1556 AVIOContext *dyn_buf = NULL;
1557 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1558 uint8_t buf[1024], *str;
1561 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1565 ret = avio_open_dyn_buf(&dyn_buf);
1570 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1571 avio_write(dyn_buf, buf, ret);
1572 avio_w8(dyn_buf, 0);
1575 ret = avio_close_dyn_buf(dyn_buf, &str);
1581 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1584 AVStream *st = ost->st;
1586 if (ost->filters_script && ost->filters) {
1587 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1588 "output stream #%d:%d.\n", nb_output_files, st->index);
1592 if (ost->filters_script)
1593 return read_file(ost->filters_script);
1594 else if (ost->filters)
1595 return av_strdup(ost->filters);
1597 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1601 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1602 const OutputStream *ost, enum AVMediaType type)
1604 if (ost->filters_script || ost->filters) {
1605 av_log(NULL, AV_LOG_ERROR,
1606 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1607 "Filtering and streamcopy cannot be used together.\n",
1608 ost->filters ? "Filtergraph" : "Filtergraph script",
1609 ost->filters ? ost->filters : ost->filters_script,
1610 av_get_media_type_string(type), ost->file_index, ost->index);
1615 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1619 AVCodecContext *video_enc;
1620 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1622 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1624 video_enc = ost->enc_ctx;
1626 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1627 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1631 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1632 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1634 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1635 if (frame_aspect_ratio) {
1637 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1638 q.num <= 0 || q.den <= 0) {
1639 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1642 ost->frame_aspect_ratio = q;
1645 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1646 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1648 if (!ost->stream_copy) {
1649 const char *p = NULL;
1650 char *frame_size = NULL;
1651 char *frame_pix_fmt = NULL;
1652 char *intra_matrix = NULL, *inter_matrix = NULL;
1653 char *chroma_intra_matrix = NULL;
1657 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1658 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1659 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1663 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1664 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1665 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1666 ost->keep_pix_fmt = 1;
1667 if (!*++frame_pix_fmt)
1668 frame_pix_fmt = NULL;
1670 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1671 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1674 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1677 video_enc->gop_size = 0;
1678 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1680 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1681 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1684 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1686 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1687 if (chroma_intra_matrix) {
1688 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1690 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1693 video_enc->chroma_intra_matrix = p;
1694 parse_matrix_coeffs(p, chroma_intra_matrix);
1696 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1698 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1699 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1702 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1705 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1706 for (i = 0; p; i++) {
1708 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1710 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1713 video_enc->rc_override =
1714 av_realloc_array(video_enc->rc_override,
1715 i + 1, sizeof(RcOverride));
1716 if (!video_enc->rc_override) {
1717 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1720 video_enc->rc_override[i].start_frame = start;
1721 video_enc->rc_override[i].end_frame = end;
1723 video_enc->rc_override[i].qscale = q;
1724 video_enc->rc_override[i].quality_factor = 1.0;
1727 video_enc->rc_override[i].qscale = 0;
1728 video_enc->rc_override[i].quality_factor = -q/100.0;
1733 video_enc->rc_override_count = i;
1736 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1739 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1742 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1743 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1746 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1747 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1751 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1752 if (ost->logfile_prefix &&
1753 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1757 char logfilename[1024];
1760 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1761 ost->logfile_prefix ? ost->logfile_prefix :
1762 DEFAULT_PASS_LOGFILENAME_PREFIX,
1764 if (!strcmp(ost->enc->name, "libx264")) {
1765 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1767 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1768 char *logbuffer = read_file(logfilename);
1771 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1775 video_enc->stats_in = logbuffer;
1777 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1778 f = av_fopen_utf8(logfilename, "wb");
1780 av_log(NULL, AV_LOG_FATAL,
1781 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1782 logfilename, strerror(errno));
1790 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1791 if (ost->forced_keyframes)
1792 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1794 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1796 ost->top_field_first = -1;
1797 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1800 ost->avfilter = get_ost_filters(o, oc, ost);
1804 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1807 if (ost->stream_copy)
1808 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1813 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1818 AVCodecContext *audio_enc;
1820 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1823 audio_enc = ost->enc_ctx;
1824 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1826 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1827 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1829 if (!ost->stream_copy) {
1830 char *sample_fmt = NULL;
1832 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1834 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1836 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1837 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1841 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1843 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1844 ost->apad = av_strdup(ost->apad);
1846 ost->avfilter = get_ost_filters(o, oc, ost);
1850 /* check for channel mapping for this audio stream */
1851 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1852 AudioChannelMap *map = &o->audio_channel_maps[n];
1853 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1854 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1857 if (map->channel_idx == -1) {
1859 } else if (ost->source_index < 0) {
1860 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1861 ost->file_index, ost->st->index);
1864 ist = input_streams[ost->source_index];
1867 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1868 if (av_reallocp_array(&ost->audio_channels_map,
1869 ost->audio_channels_mapped + 1,
1870 sizeof(*ost->audio_channels_map)
1874 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1880 if (ost->stream_copy)
1881 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1886 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1890 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1891 if (!ost->stream_copy) {
1892 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1899 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1903 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1904 if (!ost->stream_copy) {
1905 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1912 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1914 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1915 ost->stream_copy = 1;
1920 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1924 AVCodecContext *subtitle_enc;
1926 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1928 subtitle_enc = ost->enc_ctx;
1930 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1932 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1934 if (!ost->stream_copy) {
1935 char *frame_size = NULL;
1937 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1938 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1939 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1947 /* arg format is "output-stream-index:streamid-value". */
1948 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1950 OptionsContext *o = optctx;
1955 av_strlcpy(idx_str, arg, sizeof(idx_str));
1956 p = strchr(idx_str, ':');
1958 av_log(NULL, AV_LOG_FATAL,
1959 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1964 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1965 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1966 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1970 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1972 AVFormatContext *is = ifile->ctx;
1973 AVFormatContext *os = ofile->ctx;
1977 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1979 return AVERROR(ENOMEM);
1982 for (i = 0; i < is->nb_chapters; i++) {
1983 AVChapter *in_ch = is->chapters[i], *out_ch;
1984 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1985 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1986 AV_TIME_BASE_Q, in_ch->time_base);
1987 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1988 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1991 if (in_ch->end < ts_off)
1993 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1996 out_ch = av_mallocz(sizeof(AVChapter));
1998 return AVERROR(ENOMEM);
2000 out_ch->id = in_ch->id;
2001 out_ch->time_base = in_ch->time_base;
2002 out_ch->start = FFMAX(0, in_ch->start - ts_off);
2003 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2006 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2008 os->chapters[os->nb_chapters++] = out_ch;
2013 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2014 AVFormatContext *oc)
2018 switch (ofilter->type) {
2019 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2020 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2022 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2027 ost->source_index = -1;
2028 ost->filter = ofilter;
2031 ofilter->format = -1;
2033 if (ost->stream_copy) {
2034 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2035 "which is fed from a complex filtergraph. Filtering and streamcopy "
2036 "cannot be used together.\n", ost->file_index, ost->index);
2040 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2041 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2042 av_log(NULL, AV_LOG_ERROR,
2043 "%s '%s' was specified through the %s option "
2044 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2045 "%s and -filter_complex cannot be used together for the same stream.\n",
2046 ost->filters ? "Filtergraph" : "Filtergraph script",
2047 ost->filters ? ost->filters : ost->filters_script,
2048 opt, ost->file_index, ost->index, opt);
2052 avfilter_inout_free(&ofilter->out_tmp);
2055 static int init_complex_filters(void)
2059 for (i = 0; i < nb_filtergraphs; i++) {
2060 ret = init_complex_filtergraph(filtergraphs[i]);
2067 static int open_output_file(OptionsContext *o, const char *filename)
2069 AVFormatContext *oc;
2074 AVDictionary *unused_opts = NULL;
2075 AVDictionaryEntry *e = NULL;
2076 int format_flags = 0;
2078 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2079 o->stop_time = INT64_MAX;
2080 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2083 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2084 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2085 if (o->stop_time <= start_time) {
2086 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2089 o->recording_time = o->stop_time - start_time;
2093 GROW_ARRAY(output_files, nb_output_files);
2094 of = av_mallocz(sizeof(*of));
2097 output_files[nb_output_files - 1] = of;
2099 of->ost_index = nb_output_streams;
2100 of->recording_time = o->recording_time;
2101 of->start_time = o->start_time;
2102 of->limit_filesize = o->limit_filesize;
2103 of->shortest = o->shortest;
2104 av_dict_copy(&of->opts, o->g->format_opts, 0);
2106 if (!strcmp(filename, "-"))
2109 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2111 print_error(filename, err);
2116 if (o->recording_time != INT64_MAX)
2117 oc->duration = o->recording_time;
2119 oc->interrupt_callback = int_cb;
2121 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2123 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2124 av_opt_eval_flags(oc, o, e->value, &format_flags);
2127 format_flags |= AVFMT_FLAG_BITEXACT;
2128 oc->flags |= AVFMT_FLAG_BITEXACT;
2131 /* create streams for all unlabeled output pads */
2132 for (i = 0; i < nb_filtergraphs; i++) {
2133 FilterGraph *fg = filtergraphs[i];
2134 for (j = 0; j < fg->nb_outputs; j++) {
2135 OutputFilter *ofilter = fg->outputs[j];
2137 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2140 switch (ofilter->type) {
2141 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2142 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2143 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2145 init_output_filter(ofilter, o, oc);
2149 if (!o->nb_stream_maps) {
2150 char *subtitle_codec_name = NULL;
2151 /* pick the "best" stream of each type */
2153 /* video: highest resolution */
2154 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2155 int area = 0, idx = -1;
2156 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2157 for (i = 0; i < nb_input_streams; i++) {
2159 ist = input_streams[i];
2160 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2161 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2163 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2165 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2172 new_video_stream(o, oc, idx);
2175 /* audio: most channels */
2176 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2177 int best_score = 0, idx = -1;
2178 for (i = 0; i < nb_input_streams; i++) {
2180 ist = input_streams[i];
2181 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2182 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2183 score > best_score) {
2189 new_audio_stream(o, oc, idx);
2192 /* subtitles: pick first */
2193 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2194 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2195 for (i = 0; i < nb_input_streams; i++)
2196 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2197 AVCodecDescriptor const *input_descriptor =
2198 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2199 AVCodecDescriptor const *output_descriptor = NULL;
2200 AVCodec const *output_codec =
2201 avcodec_find_encoder(oc->oformat->subtitle_codec);
2202 int input_props = 0, output_props = 0;
2204 output_descriptor = avcodec_descriptor_get(output_codec->id);
2205 if (input_descriptor)
2206 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2207 if (output_descriptor)
2208 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2209 if (subtitle_codec_name ||
2210 input_props & output_props ||
2211 // Map dvb teletext which has neither property to any output subtitle encoder
2212 input_descriptor && output_descriptor &&
2213 (!input_descriptor->props ||
2214 !output_descriptor->props)) {
2215 new_subtitle_stream(o, oc, i);
2220 /* Data only if codec id match */
2221 if (!o->data_disable ) {
2222 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2223 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2224 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2225 && input_streams[i]->st->codecpar->codec_id == codec_id )
2226 new_data_stream(o, oc, i);
2230 for (i = 0; i < o->nb_stream_maps; i++) {
2231 StreamMap *map = &o->stream_maps[i];
2236 if (map->linklabel) {
2238 OutputFilter *ofilter = NULL;
2241 for (j = 0; j < nb_filtergraphs; j++) {
2242 fg = filtergraphs[j];
2243 for (k = 0; k < fg->nb_outputs; k++) {
2244 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2245 if (out && !strcmp(out->name, map->linklabel)) {
2246 ofilter = fg->outputs[k];
2253 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2254 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2257 init_output_filter(ofilter, o, oc);
2259 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2261 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2262 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2264 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2266 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2268 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2272 switch (ist->st->codecpar->codec_type) {
2273 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2274 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2275 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2276 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2277 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2278 case AVMEDIA_TYPE_UNKNOWN:
2279 if (copy_unknown_streams) {
2280 ost = new_unknown_stream (o, oc, src_idx);
2284 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2285 "Cannot map stream #%d:%d - unsupported type.\n",
2286 map->file_index, map->stream_index);
2287 if (!ignore_unknown_streams) {
2288 av_log(NULL, AV_LOG_FATAL,
2289 "If you want unsupported types ignored instead "
2290 "of failing, please use the -ignore_unknown option\n"
2291 "If you want them copied, please use -copy_unknown\n");
2296 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2297 + map->sync_stream_index];
2302 /* handle attached files */
2303 for (i = 0; i < o->nb_attachments; i++) {
2305 uint8_t *attachment;
2309 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2310 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2314 if ((len = avio_size(pb)) <= 0) {
2315 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2319 if (!(attachment = av_malloc(len))) {
2320 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2324 avio_read(pb, attachment, len);
2326 ost = new_attachment_stream(o, oc, -1);
2327 ost->stream_copy = 0;
2328 ost->attachment_filename = o->attachments[i];
2329 ost->st->codecpar->extradata = attachment;
2330 ost->st->codecpar->extradata_size = len;
2332 p = strrchr(o->attachments[i], '/');
2333 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2337 #if FF_API_LAVF_AVCTX
2338 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2339 AVDictionaryEntry *e;
2340 ost = output_streams[i];
2342 if ((ost->stream_copy || ost->attachment_filename)
2343 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2344 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2345 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2350 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2351 av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2352 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2356 /* check if all codec options have been used */
2357 unused_opts = strip_specifiers(o->g->codec_opts);
2358 for (i = of->ost_index; i < nb_output_streams; i++) {
2360 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2361 AV_DICT_IGNORE_SUFFIX)))
2362 av_dict_set(&unused_opts, e->key, NULL, 0);
2366 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2367 const AVClass *class = avcodec_get_class();
2368 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2369 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2370 const AVClass *fclass = avformat_get_class();
2371 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2372 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2373 if (!option || foption)
2377 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2378 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2379 "output file #%d (%s) is not an encoding option.\n", e->key,
2380 option->help ? option->help : "", nb_output_files - 1,
2385 // gop_timecode is injected by generic code but not always used
2386 if (!strcmp(e->key, "gop_timecode"))
2389 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2390 "output file #%d (%s) has not been used for any stream. The most "
2391 "likely reason is either wrong type (e.g. a video option with "
2392 "no video streams) or that it is a private option of some encoder "
2393 "which was not actually used for any stream.\n", e->key,
2394 option->help ? option->help : "", nb_output_files - 1, filename);
2396 av_dict_free(&unused_opts);
2398 /* set the decoding_needed flags and create simple filtergraphs */
2399 for (i = of->ost_index; i < nb_output_streams; i++) {
2400 OutputStream *ost = output_streams[i];
2402 if (ost->encoding_needed && ost->source_index >= 0) {
2403 InputStream *ist = input_streams[ost->source_index];
2404 ist->decoding_needed |= DECODING_FOR_OST;
2406 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2407 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2408 err = init_simple_filtergraph(ist, ost);
2410 av_log(NULL, AV_LOG_ERROR,
2411 "Error initializing a simple filtergraph between streams "
2412 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2413 nb_output_files - 1, ost->st->index);
2419 /* set the filter output constraints */
2421 OutputFilter *f = ost->filter;
2423 switch (ost->enc_ctx->codec_type) {
2424 case AVMEDIA_TYPE_VIDEO:
2425 f->frame_rate = ost->frame_rate;
2426 f->width = ost->enc_ctx->width;
2427 f->height = ost->enc_ctx->height;
2428 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2429 f->format = ost->enc_ctx->pix_fmt;
2430 } else if (ost->enc->pix_fmts) {
2432 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2434 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2437 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2440 case AVMEDIA_TYPE_AUDIO:
2441 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2442 f->format = ost->enc_ctx->sample_fmt;
2443 } else if (ost->enc->sample_fmts) {
2445 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2447 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2450 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2452 if (ost->enc_ctx->sample_rate) {
2453 f->sample_rate = ost->enc_ctx->sample_rate;
2454 } else if (ost->enc->supported_samplerates) {
2456 while (ost->enc->supported_samplerates[count])
2458 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2459 if (!f->sample_rates)
2461 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2462 (count + 1) * sizeof(*f->sample_rates));
2464 if (ost->enc_ctx->channels) {
2465 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2466 } else if (ost->enc->channel_layouts) {
2468 while (ost->enc->channel_layouts[count])
2470 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2471 if (!f->channel_layouts)
2473 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2474 (count + 1) * sizeof(*f->channel_layouts));
2481 /* check filename in case of an image number is expected */
2482 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2483 if (!av_filename_number_test(oc->url)) {
2484 print_error(oc->url, AVERROR(EINVAL));
2489 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2490 av_log(NULL, AV_LOG_ERROR,
2491 "No input streams but output needs an input stream\n");
2495 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2496 /* test if it already exists to avoid losing precious files */
2497 assert_file_overwrite(filename);
2500 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2501 &oc->interrupt_callback,
2503 print_error(filename, err);
2506 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2507 assert_file_overwrite(filename);
2509 if (o->mux_preload) {
2510 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2512 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2515 for (i = 0; i < o->nb_metadata_map; i++) {
2517 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2519 if (in_file_index >= nb_input_files) {
2520 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2523 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2524 in_file_index >= 0 ?
2525 input_files[in_file_index]->ctx : NULL, o);
2529 if (o->chapters_input_file >= nb_input_files) {
2530 if (o->chapters_input_file == INT_MAX) {
2531 /* copy chapters from the first input file that has them*/
2532 o->chapters_input_file = -1;
2533 for (i = 0; i < nb_input_files; i++)
2534 if (input_files[i]->ctx->nb_chapters) {
2535 o->chapters_input_file = i;
2539 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2540 o->chapters_input_file);
2544 if (o->chapters_input_file >= 0)
2545 copy_chapters(input_files[o->chapters_input_file], of,
2546 !o->metadata_chapters_manual);
2548 /* copy global metadata by default */
2549 if (!o->metadata_global_manual && nb_input_files){
2550 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2551 AV_DICT_DONT_OVERWRITE);
2552 if(o->recording_time != INT64_MAX)
2553 av_dict_set(&oc->metadata, "duration", NULL, 0);
2554 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2556 if (!o->metadata_streams_manual)
2557 for (i = of->ost_index; i < nb_output_streams; i++) {
2559 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2561 ist = input_streams[output_streams[i]->source_index];
2562 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2563 if (!output_streams[i]->stream_copy) {
2564 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2568 /* process manually set programs */
2569 for (i = 0; i < o->nb_program; i++) {
2570 const char *p = o->program[i].u.str;
2575 const char *p2 = av_get_token(&p, ":");
2576 const char *to_dealloc = p2;
2583 key = av_get_token(&p2, "=");
2585 av_freep(&to_dealloc);
2591 if (!strcmp(key, "program_num"))
2592 progid = strtol(p2, NULL, 0);
2593 av_freep(&to_dealloc);
2597 program = av_new_program(oc, progid);
2599 p = o->program[i].u.str;
2601 const char *p2 = av_get_token(&p, ":");
2602 const char *to_dealloc = p2;
2608 key = av_get_token(&p2, "=");
2610 av_log(NULL, AV_LOG_FATAL,
2611 "No '=' character in program string %s.\n",
2619 if (!strcmp(key, "title")) {
2620 av_dict_set(&program->metadata, "title", p2, 0);
2621 } else if (!strcmp(key, "program_num")) {
2622 } else if (!strcmp(key, "st")) {
2623 int st_num = strtol(p2, NULL, 0);
2624 av_program_add_stream_index(oc, progid, st_num);
2626 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2629 av_freep(&to_dealloc);
2634 /* process manually set metadata */
2635 for (i = 0; i < o->nb_metadata; i++) {
2638 const char *stream_spec;
2639 int index = 0, j, ret = 0;
2641 val = strchr(o->metadata[i].u.str, '=');
2643 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2644 o->metadata[i].u.str);
2649 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2651 for (j = 0; j < oc->nb_streams; j++) {
2652 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2653 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2654 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2656 double theta = av_strtod(val, &tail);
2658 ost->rotate_overridden = 1;
2659 ost->rotate_override_value = theta;
2662 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2674 if (index < 0 || index >= oc->nb_chapters) {
2675 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2678 m = &oc->chapters[index]->metadata;
2681 if (index < 0 || index >= oc->nb_programs) {
2682 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2685 m = &oc->programs[index]->metadata;
2688 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2691 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2698 static int opt_target(void *optctx, const char *opt, const char *arg)
2700 OptionsContext *o = optctx;
2701 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2702 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2704 if (!strncmp(arg, "pal-", 4)) {
2707 } else if (!strncmp(arg, "ntsc-", 5)) {
2710 } else if (!strncmp(arg, "film-", 5)) {
2714 /* Try to determine PAL/NTSC by peeking in the input files */
2715 if (nb_input_files) {
2717 for (j = 0; j < nb_input_files; j++) {
2718 for (i = 0; i < input_files[j]->nb_streams; i++) {
2719 AVStream *st = input_files[j]->ctx->streams[i];
2720 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2722 fr = st->time_base.den * 1000 / st->time_base.num;
2726 } else if ((fr == 29970) || (fr == 23976)) {
2731 if (norm != UNKNOWN)
2735 if (norm != UNKNOWN)
2736 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2739 if (norm == UNKNOWN) {
2740 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2741 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2742 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2746 if (!strcmp(arg, "vcd")) {
2747 opt_video_codec(o, "c:v", "mpeg1video");
2748 opt_audio_codec(o, "c:a", "mp2");
2749 parse_option(o, "f", "vcd", options);
2751 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2752 parse_option(o, "r", frame_rates[norm], options);
2753 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2755 opt_default(NULL, "b:v", "1150000");
2756 opt_default(NULL, "maxrate:v", "1150000");
2757 opt_default(NULL, "minrate:v", "1150000");
2758 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2760 opt_default(NULL, "b:a", "224000");
2761 parse_option(o, "ar", "44100", options);
2762 parse_option(o, "ac", "2", options);
2764 opt_default(NULL, "packetsize", "2324");
2765 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2767 /* We have to offset the PTS, so that it is consistent with the SCR.
2768 SCR starts at 36000, but the first two packs contain only padding
2769 and the first pack from the other stream, respectively, may also have
2770 been written before.
2771 So the real data starts at SCR 36000+3*1200. */
2772 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2773 } else if (!strcmp(arg, "svcd")) {
2775 opt_video_codec(o, "c:v", "mpeg2video");
2776 opt_audio_codec(o, "c:a", "mp2");
2777 parse_option(o, "f", "svcd", options);
2779 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2780 parse_option(o, "r", frame_rates[norm], options);
2781 parse_option(o, "pix_fmt", "yuv420p", options);
2782 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2784 opt_default(NULL, "b:v", "2040000");
2785 opt_default(NULL, "maxrate:v", "2516000");
2786 opt_default(NULL, "minrate:v", "0"); // 1145000;
2787 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2788 opt_default(NULL, "scan_offset", "1");
2790 opt_default(NULL, "b:a", "224000");
2791 parse_option(o, "ar", "44100", options);
2793 opt_default(NULL, "packetsize", "2324");
2795 } else if (!strcmp(arg, "dvd")) {
2797 opt_video_codec(o, "c:v", "mpeg2video");
2798 opt_audio_codec(o, "c:a", "ac3");
2799 parse_option(o, "f", "dvd", options);
2801 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2802 parse_option(o, "r", frame_rates[norm], options);
2803 parse_option(o, "pix_fmt", "yuv420p", options);
2804 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2806 opt_default(NULL, "b:v", "6000000");
2807 opt_default(NULL, "maxrate:v", "9000000");
2808 opt_default(NULL, "minrate:v", "0"); // 1500000;
2809 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2811 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2812 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2814 opt_default(NULL, "b:a", "448000");
2815 parse_option(o, "ar", "48000", options);
2817 } else if (!strncmp(arg, "dv", 2)) {
2819 parse_option(o, "f", "dv", options);
2821 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2822 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2823 norm == PAL ? "yuv420p" : "yuv411p", options);
2824 parse_option(o, "r", frame_rates[norm], options);
2826 parse_option(o, "ar", "48000", options);
2827 parse_option(o, "ac", "2", options);
2830 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2831 return AVERROR(EINVAL);
2834 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2835 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2840 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2842 av_free (vstats_filename);
2843 vstats_filename = av_strdup (arg);
2847 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2850 time_t today2 = time(NULL);
2851 struct tm *today = localtime(&today2);
2853 if (!today) { // maybe tomorrow
2854 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2858 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2860 return opt_vstats_file(NULL, opt, filename);
2863 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2865 OptionsContext *o = optctx;
2866 return parse_option(o, "frames:v", arg, options);
2869 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2871 OptionsContext *o = optctx;
2872 return parse_option(o, "frames:a", arg, options);
2875 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2877 OptionsContext *o = optctx;
2878 return parse_option(o, "frames:d", arg, options);
2881 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2884 AVDictionary *cbak = codec_opts;
2885 AVDictionary *fbak = format_opts;
2889 ret = opt_default(NULL, opt, arg);
2891 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2892 av_dict_copy(&o->g->format_opts, format_opts, 0);
2893 av_dict_free(&codec_opts);
2894 av_dict_free(&format_opts);
2901 static int opt_preset(void *optctx, const char *opt, const char *arg)
2903 OptionsContext *o = optctx;
2905 char filename[1000], line[1000], tmp_line[1000];
2906 const char *codec_name = NULL;
2910 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2912 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2913 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2914 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2916 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2920 while (fgets(line, sizeof(line), f)) {
2921 char *key = tmp_line, *value, *endptr;
2923 if (strcspn(line, "#\n\r") == 0)
2925 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2926 if (!av_strtok(key, "=", &value) ||
2927 !av_strtok(value, "\r\n", &endptr)) {
2928 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2931 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2933 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2934 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2935 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2936 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2937 else if (opt_default_new(o, key, value) < 0) {
2938 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2939 filename, line, key, value);
2949 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2951 OptionsContext *o = optctx;
2952 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2953 int ret = parse_option(o, s, arg, options);
2958 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2960 OptionsContext *o = optctx;
2962 if(!strcmp(opt, "ab")){
2963 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2965 } else if(!strcmp(opt, "b")){
2966 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2967 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2970 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2974 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2976 OptionsContext *o = optctx;
2979 if(!strcmp(opt, "qscale")){
2980 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2981 return parse_option(o, "q:v", arg, options);
2983 s = av_asprintf("q%s", opt + 6);
2984 ret = parse_option(o, s, arg, options);
2989 static int opt_profile(void *optctx, const char *opt, const char *arg)
2991 OptionsContext *o = optctx;
2992 if(!strcmp(opt, "profile")){
2993 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2994 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2997 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3001 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3003 OptionsContext *o = optctx;
3004 return parse_option(o, "filter:v", arg, options);
3007 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3009 OptionsContext *o = optctx;
3010 return parse_option(o, "filter:a", arg, options);
3013 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3015 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3016 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3017 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3018 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3020 if (video_sync_method == VSYNC_AUTO)
3021 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3025 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3027 OptionsContext *o = optctx;
3028 char *tcr = av_asprintf("timecode=%s", arg);
3029 int ret = parse_option(o, "metadata:g", tcr, options);
3031 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3036 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3038 OptionsContext *o = optctx;
3039 char layout_str[32];
3042 int ret, channels, ac_str_size;
3045 layout = av_get_channel_layout(arg);
3047 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3048 return AVERROR(EINVAL);
3050 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3051 ret = opt_default_new(o, opt, layout_str);
3055 /* set 'ac' option based on channel layout */
3056 channels = av_get_channel_layout_nb_channels(layout);
3057 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3058 stream_str = strchr(opt, ':');
3059 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3060 ac_str = av_mallocz(ac_str_size);
3062 return AVERROR(ENOMEM);
3063 av_strlcpy(ac_str, "ac", 3);
3065 av_strlcat(ac_str, stream_str, ac_str_size);
3066 ret = parse_option(o, ac_str, layout_str, options);
3072 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3074 OptionsContext *o = optctx;
3075 return parse_option(o, "q:a", arg, options);
3078 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3080 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3081 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3082 return AVERROR(ENOMEM);
3083 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3084 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3085 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3086 return AVERROR(ENOMEM);
3088 input_stream_potentially_available = 1;
3093 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3095 uint8_t *graph_desc = read_file(arg);
3097 return AVERROR(EINVAL);
3099 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3100 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3101 return AVERROR(ENOMEM);
3102 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3103 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3105 input_stream_potentially_available = 1;
3110 void show_help_default(const char *opt, const char *arg)
3112 /* per-file options have at least one of those set */
3113 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3114 int show_advanced = 0, show_avoptions = 0;
3117 if (!strcmp(opt, "long"))
3119 else if (!strcmp(opt, "full"))
3120 show_advanced = show_avoptions = 1;
3122 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3127 printf("Getting help:\n"
3128 " -h -- print basic options\n"
3129 " -h long -- print more options\n"
3130 " -h full -- print all options (including all format and codec specific options, very long)\n"
3131 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3132 " See man %s for detailed description of the options.\n"
3133 "\n", program_name);
3135 show_help_options(options, "Print help / information / capabilities:",
3138 show_help_options(options, "Global options (affect whole program "
3139 "instead of just one file:",
3140 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3142 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3143 per_file | OPT_EXIT, 0);
3145 show_help_options(options, "Per-file main options:", 0,
3146 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3147 OPT_EXIT, per_file);
3149 show_help_options(options, "Advanced per-file options:",
3150 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3152 show_help_options(options, "Video options:",
3153 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3155 show_help_options(options, "Advanced Video options:",
3156 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3158 show_help_options(options, "Audio options:",
3159 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3161 show_help_options(options, "Advanced Audio options:",
3162 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3163 show_help_options(options, "Subtitle options:",
3164 OPT_SUBTITLE, 0, 0);
3167 if (show_avoptions) {
3168 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3169 show_help_children(avcodec_get_class(), flags);
3170 show_help_children(avformat_get_class(), flags);
3172 show_help_children(sws_get_class(), flags);
3174 #if CONFIG_SWRESAMPLE
3175 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3177 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3178 show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3182 void show_usage(void)
3184 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3185 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3186 av_log(NULL, AV_LOG_INFO, "\n");
3194 static const OptionGroupDef groups[] = {
3195 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3196 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3199 static int open_files(OptionGroupList *l, const char *inout,
3200 int (*open_file)(OptionsContext*, const char*))
3204 for (i = 0; i < l->nb_groups; i++) {
3205 OptionGroup *g = &l->groups[i];
3211 ret = parse_optgroup(&o, g);
3213 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3214 "%s.\n", inout, g->arg);
3218 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3219 ret = open_file(&o, g->arg);
3222 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3226 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3232 int ffmpeg_parse_options(int argc, char **argv)
3234 OptionParseContext octx;
3238 memset(&octx, 0, sizeof(octx));
3240 /* split the commandline into an internal representation */
3241 ret = split_commandline(&octx, argc, argv, options, groups,
3242 FF_ARRAY_ELEMS(groups));
3244 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3248 /* apply global options */
3249 ret = parse_optgroup(NULL, &octx.global_opts);
3251 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3255 /* configure terminal and setup signal handlers */
3258 /* open input files */
3259 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3261 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3265 /* create the complex filtergraphs */
3266 ret = init_complex_filters();
3268 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3272 /* open output files */
3273 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3275 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3279 check_filter_outputs();
3282 uninit_parse_context(&octx);
3284 av_strerror(ret, error, sizeof(error));
3285 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3290 static int opt_progress(void *optctx, const char *opt, const char *arg)
3292 AVIOContext *avio = NULL;
3295 if (!strcmp(arg, "-"))
3297 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3299 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3300 arg, av_err2str(ret));
3303 progress_avio = avio;
3307 #define OFFSET(x) offsetof(OptionsContext, x)
3308 const OptionDef options[] = {
3310 CMDUTILS_COMMON_OPTIONS
3311 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3312 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3313 "force format", "fmt" },
3314 { "y", OPT_BOOL, { &file_overwrite },
3315 "overwrite output files" },
3316 { "n", OPT_BOOL, { &no_file_overwrite },
3317 "never overwrite output files" },
3318 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3319 "Ignore unknown stream types" },
3320 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3321 "Copy unknown stream types" },
3322 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3323 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3324 "codec name", "codec" },
3325 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3326 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3327 "codec name", "codec" },
3328 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3329 OPT_OUTPUT, { .off = OFFSET(presets) },
3330 "preset name", "preset" },
3331 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3332 OPT_OUTPUT, { .func_arg = opt_map },
3333 "set input stream mapping",
3334 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3335 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3336 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3337 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3338 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3339 "set metadata information of outfile from infile",
3340 "outfile[,metadata]:infile[,metadata]" },
3341 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3342 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3343 "set chapters mapping", "input_file_index" },
3344 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3345 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3346 "record or transcode \"duration\" seconds of audio/video",
3348 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3349 "record or transcode stop time", "time_stop" },
3350 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3351 "set the limit file size in bytes", "limit_size" },
3352 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3353 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3354 "set the start time offset", "time_off" },
3355 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3356 OPT_INPUT, { .off = OFFSET(start_time_eof) },
3357 "set the start time offset relative to EOF", "time_off" },
3358 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3359 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3360 "enable/disable seeking by timestamp with -ss" },
3361 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3362 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3363 "enable/disable accurate seeking with -ss" },
3364 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3365 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3366 "set the input ts offset", "time_off" },
3367 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3368 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3369 "set the input ts scale", "scale" },
3370 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3371 "set the recording timestamp ('now' to set the current time)", "time" },
3372 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3373 "add metadata", "string=string" },
3374 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3375 "add program with specified streams", "title=string:st=number..." },
3376 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3377 OPT_OUTPUT, { .func_arg = opt_data_frames },
3378 "set the number of data frames to output", "number" },
3379 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3380 "add timings for benchmarking" },
3381 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3382 "add timings for each task" },
3383 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3384 "write program-readable progress information", "url" },
3385 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3386 "enable or disable interaction on standard input" },
3387 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3388 "set max runtime in seconds", "limit" },
3389 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3390 "dump each input packet" },
3391 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3392 "when dumping packets, also dump the payload" },
3393 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3394 OPT_INPUT, { .off = OFFSET(rate_emu) },
3395 "read input at native frame rate", "" },
3396 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3397 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3398 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3399 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3400 "video sync method", "" },
3401 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3402 "frame drop threshold", "" },
3403 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3404 "audio sync method", "" },
3405 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3406 "audio drift threshold", "threshold" },
3407 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3408 "copy timestamps" },
3409 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3410 "shift input timestamps to start at 0 when using copyts" },
3411 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3412 "copy input stream time base when stream copying", "mode" },
3413 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3414 OPT_OUTPUT, { .off = OFFSET(shortest) },
3415 "finish encoding within shortest input" },
3416 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3417 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3419 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3420 OPT_OUTPUT, { .off = OFFSET(apad) },
3422 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3423 "timestamp discontinuity delta threshold", "threshold" },
3424 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3425 "timestamp error delta threshold", "threshold" },
3426 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3427 "exit on error", "error" },
3428 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3429 "abort on the specified condition flags", "flags" },
3430 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3431 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3432 "copy initial non-keyframes" },
3433 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3434 "copy or discard frames before start time" },
3435 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3436 "set the number of frames to output", "number" },
3437 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3438 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3439 "force codec tag/fourcc", "fourcc/tag" },
3440 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3441 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3442 "use fixed quality scale (VBR)", "q" },
3443 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3444 OPT_OUTPUT, { .func_arg = opt_qscale },
3445 "use fixed quality scale (VBR)", "q" },
3446 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3447 "set profile", "profile" },
3448 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3449 "set stream filtergraph", "filter_graph" },
3450 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3451 "number of non-complex filter threads" },
3452 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3453 "read stream filtergraph description from a file", "filename" },
3454 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3455 "reinit filtergraph on input parameter changes", "" },
3456 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3457 "create a complex filtergraph", "graph_description" },
3458 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3459 "number of threads for -filter_complex" },
3460 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3461 "create a complex filtergraph", "graph_description" },
3462 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3463 "read complex filtergraph description from a file", "filename" },
3464 { "stats", OPT_BOOL, { &print_stats },
3465 "print progress report during encoding", },
3466 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3467 OPT_OUTPUT, { .func_arg = opt_attach },
3468 "add an attachment to the output file", "filename" },
3469 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3470 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3471 "extract an attachment into a file", "filename" },
3472 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3473 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3474 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3475 "print timestamp debugging info" },
3476 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3477 "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3478 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3479 OPT_INPUT, { .off = OFFSET(discard) },
3481 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3482 OPT_OUTPUT, { .off = OFFSET(disposition) },
3483 "disposition", "" },
3484 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3485 { .off = OFFSET(thread_queue_size) },
3486 "set the maximum number of queued packets from the demuxer" },
3487 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3488 "read and decode the streams to fill missing information with heuristics" },
3491 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3492 "set the number of video frames to output", "number" },
3493 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3494 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3495 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3496 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3497 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3498 "set frame size (WxH or abbreviation)", "size" },
3499 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3500 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3501 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3502 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3503 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3504 "set pixel format", "format" },
3505 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3506 "set the number of bits per raw sample", "number" },
3507 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3508 "deprecated use -g 1" },
3509 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3511 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3512 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3513 "rate control override for specific intervals", "override" },
3514 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3515 OPT_OUTPUT, { .func_arg = opt_video_codec },
3516 "force video codec ('copy' to copy stream)", "codec" },
3517 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3519 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3521 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3522 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3523 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3524 "select the pass number (1 to 3)", "n" },
3525 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3526 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3527 "select two pass log file name prefix", "prefix" },
3528 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3529 "this option is deprecated, use the yadif filter instead" },
3530 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3531 "calculate PSNR of compressed frames" },
3532 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3533 "dump video coding statistics to file" },
3534 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3535 "dump video coding statistics to file", "file" },
3536 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3537 "Version of the vstats format to use."},
3538 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3539 "set video filters", "filter_graph" },
3540 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3541 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3542 "specify intra matrix coeffs", "matrix" },
3543 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3544 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3545 "specify inter matrix coeffs", "matrix" },
3546 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3547 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3548 "specify intra matrix coeffs", "matrix" },
3549 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3550 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3551 "top=1/bottom=0/auto=-1 field first", "" },
3552 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3553 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3554 "force video tag/fourcc", "fourcc/tag" },
3555 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3556 "show QP histogram" },
3557 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3558 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3559 "force the selected framerate, disable the best supported framerate selection" },
3560 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3561 OPT_OUTPUT, { .func_arg = opt_streamid },
3562 "set the value of an outfile streamid", "streamIndex:value" },
3563 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3564 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3565 "force key frames at specified timestamps", "timestamps" },
3566 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3567 "audio bitrate (please use -b:a)", "bitrate" },
3568 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3569 "video bitrate (please use -b:v)", "bitrate" },
3570 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3571 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3572 "use HW accelerated decoding", "hwaccel name" },
3573 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3574 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3575 "select a device for HW acceleration", "devicename" },
3576 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3577 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3578 "select output format used with HW accelerated decoding", "format" },
3579 #if CONFIG_VIDEOTOOLBOX
3580 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3582 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3583 "show available HW acceleration methods" },
3584 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3585 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3586 "automatically insert correct rotate filters" },
3589 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3590 "set the number of audio frames to output", "number" },
3591 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3592 "set audio quality (codec-specific)", "quality", },
3593 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3594 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3595 "set audio sampling rate (in Hz)", "rate" },
3596 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3597 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3598 "set number of audio channels", "channels" },
3599 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3601 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3602 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3603 "force audio codec ('copy' to copy stream)", "codec" },
3604 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3605 OPT_OUTPUT, { .func_arg = opt_old2new },
3606 "force audio tag/fourcc", "fourcc/tag" },
3607 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3608 "change audio volume (256=normal)" , "volume" },
3609 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3610 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3611 "set sample format", "format" },
3612 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3613 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3614 "set channel layout", "layout" },
3615 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3616 "set audio filters", "filter_graph" },
3617 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3618 "set the maximum number of channels to try to guess the channel layout" },
3620 /* subtitle options */
3621 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3622 "disable subtitle" },
3623 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3624 "force subtitle codec ('copy' to copy stream)", "codec" },
3625 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3626 , "force subtitle tag/fourcc", "fourcc/tag" },
3627 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3628 "fix subtitles duration" },
3629 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3630 "set canvas size (WxH or abbreviation)", "size" },
3633 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3634 "deprecated, use -channel", "channel" },
3635 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3636 "deprecated, use -standard", "standard" },
3637 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3640 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3641 "set the maximum demux-decode delay", "seconds" },
3642 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3643 "set the initial demux-decode delay", "seconds" },
3644 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3645 "specify a file in which to print sdp information", "file" },
3647 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3648 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3649 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3650 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3651 "two special values are defined - "
3652 "0 = use frame rate (video) or sample rate (audio),"
3653 "-1 = match source time base", "ratio" },
3655 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3656 "A comma-separated list of bitstream filters", "bitstream_filters" },
3657 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3658 "deprecated", "audio bitstream_filters" },
3659 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3660 "deprecated", "video bitstream_filters" },
3662 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3663 "set the audio options to the indicated preset", "preset" },
3664 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3665 "set the video options to the indicated preset", "preset" },
3666 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3667 "set the subtitle options to the indicated preset", "preset" },
3668 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3669 "set options from indicated preset file", "filename" },
3671 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3672 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3674 /* data codec support */
3675 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3676 "force data codec ('copy' to copy stream)", "codec" },
3677 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3681 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3682 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3686 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3687 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3690 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3691 "initialise hardware device", "args" },
3692 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3693 "set hardware device used when filtering", "device" },