2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
83 float dts_error_threshold = 3600*30;
85 int audio_volume = 256;
86 int audio_sync_method = 0;
87 int video_sync_method = VSYNC_AUTO;
88 int do_deinterlace = 0;
90 int do_benchmark_all = 0;
96 int exit_on_error = 0;
99 int stdin_interaction = 1;
100 int frame_bits_per_raw_sample = 0;
101 float max_error_rate = 2.0/3;
104 static int intra_only = 0;
105 static int file_overwrite = 0;
106 static int no_file_overwrite = 0;
107 static int intra_dc_precision = 8;
108 static int do_psnr = 0;
109 static int input_sync;
110 static int override_ffserver = 0;
112 static void uninit_options(OptionsContext *o)
114 const OptionDef *po = options;
117 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
119 void *dst = (uint8_t*)o + po->u.off;
121 if (po->flags & OPT_SPEC) {
122 SpecifierOpt **so = dst;
123 int i, *count = (int*)(so + 1);
124 for (i = 0; i < *count; i++) {
125 av_freep(&(*so)[i].specifier);
126 if (po->flags & OPT_STRING)
127 av_freep(&(*so)[i].u.str);
131 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
136 for (i = 0; i < o->nb_stream_maps; i++)
137 av_freep(&o->stream_maps[i].linklabel);
138 av_freep(&o->stream_maps);
139 av_freep(&o->audio_channel_maps);
140 av_freep(&o->streamid_map);
141 av_freep(&o->attachments);
144 static void init_options(OptionsContext *o)
146 memset(o, 0, sizeof(*o));
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->start_time = AV_NOPTS_VALUE;
151 o->recording_time = INT64_MAX;
152 o->limit_filesize = UINT64_MAX;
153 o->chapters_input_file = INT_MAX;
154 o->accurate_seek = 1;
157 /* return a copy of the input with the stream specifiers removed from the keys */
158 static AVDictionary *strip_specifiers(AVDictionary *dict)
160 AVDictionaryEntry *e = NULL;
161 AVDictionary *ret = NULL;
163 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
164 char *p = strchr(e->key, ':');
168 av_dict_set(&ret, e->key, e->value, 0);
175 static int opt_sameq(void *optctx, const char *opt, const char *arg)
177 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
178 "If you are looking for an option to preserve the quality (which is not "
179 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
181 return AVERROR(EINVAL);
184 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
186 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
187 return opt_default(optctx, "channel", arg);
190 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
192 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
193 return opt_default(optctx, "standard", arg);
196 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:a", arg, options);
202 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
205 return parse_option(o, "codec:v", arg, options);
208 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
210 OptionsContext *o = optctx;
211 return parse_option(o, "codec:s", arg, options);
214 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
216 OptionsContext *o = optctx;
217 return parse_option(o, "codec:d", arg, options);
220 static int opt_map(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
224 int i, negative = 0, file_idx;
225 int sync_file_idx = -1, sync_stream_idx = 0;
233 map = av_strdup(arg);
235 /* parse sync stream first, just pick first matching stream */
236 if (sync = strchr(map, ',')) {
238 sync_file_idx = strtol(sync + 1, &sync, 0);
239 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
240 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
245 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
246 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
247 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
251 if (i == input_files[sync_file_idx]->nb_streams) {
252 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
253 "match any streams.\n", arg);
260 /* this mapping refers to lavfi output */
261 const char *c = map + 1;
262 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
263 m = &o->stream_maps[o->nb_stream_maps - 1];
264 m->linklabel = av_get_token(&c, "]");
266 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
270 file_idx = strtol(map, &p, 0);
271 if (file_idx >= nb_input_files || file_idx < 0) {
272 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
276 /* disable some already defined maps */
277 for (i = 0; i < o->nb_stream_maps; i++) {
278 m = &o->stream_maps[i];
279 if (file_idx == m->file_index &&
280 check_stream_specifier(input_files[m->file_index]->ctx,
281 input_files[m->file_index]->ctx->streams[m->stream_index],
282 *p == ':' ? p + 1 : p) > 0)
286 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
287 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
288 *p == ':' ? p + 1 : p) <= 0)
290 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
291 m = &o->stream_maps[o->nb_stream_maps - 1];
293 m->file_index = file_idx;
296 if (sync_file_idx >= 0) {
297 m->sync_file_index = sync_file_idx;
298 m->sync_stream_index = sync_stream_idx;
300 m->sync_file_index = file_idx;
301 m->sync_stream_index = i;
307 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
315 static int opt_attach(void *optctx, const char *opt, const char *arg)
317 OptionsContext *o = optctx;
318 GROW_ARRAY(o->attachments, o->nb_attachments);
319 o->attachments[o->nb_attachments - 1] = arg;
323 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
330 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
331 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
333 /* muted channel syntax */
334 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
335 if ((n == 1 || n == 3) && m->channel_idx == -1) {
336 m->file_idx = m->stream_idx = -1;
338 m->ofile_idx = m->ostream_idx = -1;
343 n = sscanf(arg, "%d.%d.%d:%d.%d",
344 &m->file_idx, &m->stream_idx, &m->channel_idx,
345 &m->ofile_idx, &m->ostream_idx);
347 if (n != 3 && n != 5) {
348 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
349 "[file.stream.channel|-1][:syncfile:syncstream]\n");
353 if (n != 5) // only file.stream.channel specified
354 m->ofile_idx = m->ostream_idx = -1;
357 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
358 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
362 if (m->stream_idx < 0 ||
363 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
364 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
365 m->file_idx, m->stream_idx);
368 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
369 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
370 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
371 m->file_idx, m->stream_idx);
374 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
375 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
376 m->file_idx, m->stream_idx, m->channel_idx);
383 * Parse a metadata specifier passed as 'arg' parameter.
384 * @param arg metadata string to parse
385 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
386 * @param index for type c/p, chapter/program index is written here
387 * @param stream_spec for type s, the stream specifier is written here
389 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
397 if (*(++arg) && *arg != ':') {
398 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
401 *stream_spec = *arg == ':' ? arg + 1 : "";
406 *index = strtol(++arg, NULL, 0);
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
416 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
418 AVDictionary **meta_in = NULL;
419 AVDictionary **meta_out = NULL;
421 char type_in, type_out;
422 const char *istream_spec = NULL, *ostream_spec = NULL;
423 int idx_in = 0, idx_out = 0;
425 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
426 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
429 if (type_out == 'g' || !*outspec)
430 o->metadata_global_manual = 1;
431 if (type_out == 's' || !*outspec)
432 o->metadata_streams_manual = 1;
433 if (type_out == 'c' || !*outspec)
434 o->metadata_chapters_manual = 1;
438 if (type_in == 'g' || type_out == 'g')
439 o->metadata_global_manual = 1;
440 if (type_in == 's' || type_out == 's')
441 o->metadata_streams_manual = 1;
442 if (type_in == 'c' || type_out == 'c')
443 o->metadata_chapters_manual = 1;
445 /* ic is NULL when just disabling automatic mappings */
449 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
450 if ((index) < 0 || (index) >= (nb_elems)) {\
451 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
456 #define SET_DICT(type, meta, context, index)\
459 meta = &context->metadata;\
462 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
463 meta = &context->chapters[index]->metadata;\
466 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
467 meta = &context->programs[index]->metadata;\
470 break; /* handled separately below */ \
471 default: av_assert0(0);\
474 SET_DICT(type_in, meta_in, ic, idx_in);
475 SET_DICT(type_out, meta_out, oc, idx_out);
477 /* for input streams choose first matching stream */
478 if (type_in == 's') {
479 for (i = 0; i < ic->nb_streams; i++) {
480 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
481 meta_in = &ic->streams[i]->metadata;
487 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
492 if (type_out == 's') {
493 for (i = 0; i < oc->nb_streams; i++) {
494 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
495 meta_out = &oc->streams[i]->metadata;
496 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
506 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
508 OptionsContext *o = optctx;
510 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
511 struct tm time = *gmtime((time_t*)&recording_timestamp);
512 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
513 parse_option(o, "metadata", buf, options);
515 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
516 "tag instead.\n", opt);
520 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
522 const AVCodecDescriptor *desc;
523 const char *codec_string = encoder ? "encoder" : "decoder";
527 avcodec_find_encoder_by_name(name) :
528 avcodec_find_decoder_by_name(name);
530 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
531 codec = encoder ? avcodec_find_encoder(desc->id) :
532 avcodec_find_decoder(desc->id);
534 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
535 codec_string, codec->name, desc->name);
539 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
542 if (codec->type != type) {
543 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
549 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
551 char *codec_name = NULL;
553 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
555 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
556 st->codec->codec_id = codec->id;
559 return avcodec_find_decoder(st->codec->codec_id);
562 /* Add all the streams from the given input file to the global
563 * list of input streams. */
564 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
568 for (i = 0; i < ic->nb_streams; i++) {
569 AVStream *st = ic->streams[i];
570 AVCodecContext *dec = st->codec;
571 InputStream *ist = av_mallocz(sizeof(*ist));
572 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
573 char *codec_tag = NULL;
575 char *discard_str = NULL;
576 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
581 GROW_ARRAY(input_streams, nb_input_streams);
582 input_streams[nb_input_streams - 1] = ist;
585 ist->file_index = nb_input_files;
587 st->discard = AVDISCARD_ALL;
590 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
592 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
594 uint32_t tag = strtol(codec_tag, &next, 0);
596 tag = AV_RL32(codec_tag);
597 st->codec->codec_tag = tag;
600 ist->dec = choose_decoder(o, ic, st);
601 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
603 ist->reinit_filters = -1;
604 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
606 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
607 ist->user_set_discard = AVDISCARD_NONE;
608 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
609 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
614 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
616 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
618 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
622 ret = avcodec_copy_context(ist->dec_ctx, dec);
624 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
628 switch (dec->codec_type) {
629 case AVMEDIA_TYPE_VIDEO:
631 ist->dec = avcodec_find_decoder(dec->codec_id);
632 if (av_codec_get_lowres(dec)) {
633 dec->flags |= CODEC_FLAG_EMU_EDGE;
636 ist->resample_height = ist->dec_ctx->height;
637 ist->resample_width = ist->dec_ctx->width;
638 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
640 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
641 if (framerate && av_parse_video_rate(&ist->framerate,
643 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
648 ist->top_field_first = -1;
649 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
651 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
653 if (!strcmp(hwaccel, "none"))
654 ist->hwaccel_id = HWACCEL_NONE;
655 else if (!strcmp(hwaccel, "auto"))
656 ist->hwaccel_id = HWACCEL_AUTO;
659 for (i = 0; hwaccels[i].name; i++) {
660 if (!strcmp(hwaccels[i].name, hwaccel)) {
661 ist->hwaccel_id = hwaccels[i].id;
666 if (!ist->hwaccel_id) {
667 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
669 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
670 for (i = 0; hwaccels[i].name; i++)
671 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
672 av_log(NULL, AV_LOG_FATAL, "\n");
678 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
679 if (hwaccel_device) {
680 ist->hwaccel_device = av_strdup(hwaccel_device);
681 if (!ist->hwaccel_device)
684 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
687 case AVMEDIA_TYPE_AUDIO:
688 ist->guess_layout_max = INT_MAX;
689 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
690 guess_input_channel_layout(ist);
692 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
693 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
694 ist->resample_channels = ist->dec_ctx->channels;
695 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
698 case AVMEDIA_TYPE_DATA:
699 case AVMEDIA_TYPE_SUBTITLE: {
700 char *canvas_size = NULL;
702 ist->dec = avcodec_find_decoder(dec->codec_id);
703 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
704 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
706 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
707 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
712 case AVMEDIA_TYPE_ATTACHMENT:
713 case AVMEDIA_TYPE_UNKNOWN:
721 static void assert_file_overwrite(const char *filename)
723 if (file_overwrite && no_file_overwrite) {
724 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
728 if (!file_overwrite) {
729 const char *proto_name = avio_find_protocol_name(filename);
730 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
731 if (stdin_interaction && !no_file_overwrite) {
732 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
735 signal(SIGINT, SIG_DFL);
737 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
743 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
750 static void dump_attachment(AVStream *st, const char *filename)
753 AVIOContext *out = NULL;
754 AVDictionaryEntry *e;
756 if (!st->codec->extradata_size) {
757 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
758 nb_input_files - 1, st->index);
761 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
764 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
765 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
769 assert_file_overwrite(filename);
771 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
772 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
777 avio_write(out, st->codec->extradata, st->codec->extradata_size);
782 static int open_input_file(OptionsContext *o, const char *filename)
786 AVInputFormat *file_iformat = NULL;
791 AVDictionary *unused_opts = NULL;
792 AVDictionaryEntry *e = NULL;
793 int orig_nb_streams; // number of streams before avformat_find_stream_info
794 char * video_codec_name = NULL;
795 char * audio_codec_name = NULL;
796 char *subtitle_codec_name = NULL;
799 if (!(file_iformat = av_find_input_format(o->format))) {
800 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
805 if (!strcmp(filename, "-"))
808 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
809 strcmp(filename, "/dev/stdin");
811 /* get default parameters from command line */
812 ic = avformat_alloc_context();
814 print_error(filename, AVERROR(ENOMEM));
817 if (o->nb_audio_sample_rate) {
818 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
819 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
821 if (o->nb_audio_channels) {
822 /* because we set audio_channels based on both the "ac" and
823 * "channel_layout" options, we need to check that the specified
824 * demuxer actually has the "channels" option before setting it */
825 if (file_iformat && file_iformat->priv_class &&
826 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
827 AV_OPT_SEARCH_FAKE_OBJ)) {
828 snprintf(buf, sizeof(buf), "%d",
829 o->audio_channels[o->nb_audio_channels - 1].u.i);
830 av_dict_set(&o->g->format_opts, "channels", buf, 0);
833 if (o->nb_frame_rates) {
834 /* set the format-level framerate option;
835 * this is important for video grabbers, e.g. x11 */
836 if (file_iformat && file_iformat->priv_class &&
837 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
838 AV_OPT_SEARCH_FAKE_OBJ)) {
839 av_dict_set(&o->g->format_opts, "framerate",
840 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
843 if (o->nb_frame_sizes) {
844 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
846 if (o->nb_frame_pix_fmts)
847 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
849 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
850 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
851 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
853 ic->video_codec_id = video_codec_name ?
854 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
855 ic->audio_codec_id = audio_codec_name ?
856 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
857 ic->subtitle_codec_id= subtitle_codec_name ?
858 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
860 if (video_codec_name)
861 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
862 if (audio_codec_name)
863 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
864 if (subtitle_codec_name)
865 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
867 ic->flags |= AVFMT_FLAG_NONBLOCK;
868 ic->interrupt_callback = int_cb;
870 /* open the input file with generic avformat function */
871 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
873 print_error(filename, err);
876 assert_avoptions(o->g->format_opts);
878 /* apply forced codec ids */
879 for (i = 0; i < ic->nb_streams; i++)
880 choose_decoder(o, ic, ic->streams[i]);
882 /* Set AVCodecContext options for avformat_find_stream_info */
883 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
884 orig_nb_streams = ic->nb_streams;
886 /* If not enough info to get the stream parameters, we decode the
887 first frames to get it. (used in mpeg case for example) */
888 ret = avformat_find_stream_info(ic, opts);
890 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
891 if (ic->nb_streams == 0) {
892 avformat_close_input(&ic);
897 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
898 /* add the stream start time */
899 if (ic->start_time != AV_NOPTS_VALUE)
900 timestamp += ic->start_time;
902 /* if seeking requested, we execute it */
903 if (o->start_time != AV_NOPTS_VALUE) {
904 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
906 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
907 filename, (double)timestamp / AV_TIME_BASE);
911 /* update the current parameters so that they match the one of the input stream */
912 add_input_streams(o, ic);
914 /* dump the file content */
915 av_dump_format(ic, nb_input_files, filename, 0);
917 GROW_ARRAY(input_files, nb_input_files);
918 f = av_mallocz(sizeof(*f));
921 input_files[nb_input_files - 1] = f;
924 f->ist_index = nb_input_streams - ic->nb_streams;
925 f->start_time = o->start_time;
926 f->recording_time = o->recording_time;
927 f->input_ts_offset = o->input_ts_offset;
928 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
929 f->nb_streams = ic->nb_streams;
930 f->rate_emu = o->rate_emu;
931 f->accurate_seek = o->accurate_seek;
933 /* check if all codec options have been used */
934 unused_opts = strip_specifiers(o->g->codec_opts);
935 for (i = f->ist_index; i < nb_input_streams; i++) {
937 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
938 AV_DICT_IGNORE_SUFFIX)))
939 av_dict_set(&unused_opts, e->key, NULL, 0);
943 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
944 const AVClass *class = avcodec_get_class();
945 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
946 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
947 const AVClass *fclass = avformat_get_class();
948 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
949 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
950 if (!option || foption)
954 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
955 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
956 "input file #%d (%s) is not a decoding option.\n", e->key,
957 option->help ? option->help : "", nb_input_files - 1,
962 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
963 "input file #%d (%s) has not been used for any stream. The most "
964 "likely reason is either wrong type (e.g. a video option with "
965 "no video streams) or that it is a private option of some decoder "
966 "which was not actually used for any stream.\n", e->key,
967 option->help ? option->help : "", nb_input_files - 1, filename);
969 av_dict_free(&unused_opts);
971 for (i = 0; i < o->nb_dump_attachment; i++) {
974 for (j = 0; j < ic->nb_streams; j++) {
975 AVStream *st = ic->streams[j];
977 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
978 dump_attachment(st, o->dump_attachment[i].u.str);
982 for (i = 0; i < orig_nb_streams; i++)
983 av_dict_free(&opts[i]);
989 static uint8_t *get_line(AVIOContext *s)
995 if (avio_open_dyn_buf(&line) < 0) {
996 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1000 while ((c = avio_r8(s)) && c != '\n')
1003 avio_close_dyn_buf(line, &buf);
1008 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1011 char filename[1000];
1012 const char *base[3] = { getenv("AVCONV_DATADIR"),
1017 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1021 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1022 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1023 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1026 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1027 i != 1 ? "" : "/.avconv", preset_name);
1028 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1034 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1036 char *codec_name = NULL;
1038 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1040 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1041 NULL, ost->st->codec->codec_type);
1042 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1043 } else if (!strcmp(codec_name, "copy"))
1044 ost->stream_copy = 1;
1046 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1047 ost->st->codec->codec_id = ost->enc->id;
1051 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1054 AVStream *st = avformat_new_stream(oc, NULL);
1055 int idx = oc->nb_streams - 1, ret = 0;
1056 char *bsf = NULL, *next, *codec_tag = NULL;
1057 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1062 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1066 if (oc->nb_streams - 1 < o->nb_streamid_map)
1067 st->id = o->streamid_map[oc->nb_streams - 1];
1069 GROW_ARRAY(output_streams, nb_output_streams);
1070 if (!(ost = av_mallocz(sizeof(*ost))))
1072 output_streams[nb_output_streams - 1] = ost;
1074 ost->file_index = nb_output_files - 1;
1077 st->codec->codec_type = type;
1078 choose_encoder(o, oc, ost);
1080 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1081 if (!ost->enc_ctx) {
1082 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1085 ost->enc_ctx->codec_type = type;
1088 AVIOContext *s = NULL;
1089 char *buf = NULL, *arg = NULL, *preset = NULL;
1091 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1093 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1094 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1097 if (!buf[0] || buf[0] == '#') {
1101 if (!(arg = strchr(buf, '='))) {
1102 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1106 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1108 } while (!s->eof_reached);
1112 av_log(NULL, AV_LOG_FATAL,
1113 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1114 preset, ost->file_index, ost->index);
1118 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1121 ost->max_frames = INT64_MAX;
1122 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1123 for (i = 0; i<o->nb_max_frames; i++) {
1124 char *p = o->max_frames[i].specifier;
1125 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1126 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1131 ost->copy_prior_start = -1;
1132 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1134 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1136 if (next = strchr(bsf, ','))
1138 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1139 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1143 bsfc_prev->next = bsfc;
1145 ost->bitstream_filters = bsfc;
1151 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1153 uint32_t tag = strtol(codec_tag, &next, 0);
1155 tag = AV_RL32(codec_tag);
1156 ost->enc_ctx->codec_tag = tag;
1159 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1161 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1162 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1165 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1166 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1168 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1170 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1171 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1172 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1174 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1176 ost->source_index = source_index;
1177 if (source_index >= 0) {
1178 ost->sync_ist = input_streams[source_index];
1179 input_streams[source_index]->discard = 0;
1180 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1182 ost->last_mux_dts = AV_NOPTS_VALUE;
1187 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1190 const char *p = str;
1197 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1204 /* read file contents into a string */
1205 static uint8_t *read_file(const char *filename)
1207 AVIOContext *pb = NULL;
1208 AVIOContext *dyn_buf = NULL;
1209 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1210 uint8_t buf[1024], *str;
1213 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1217 ret = avio_open_dyn_buf(&dyn_buf);
1222 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1223 avio_write(dyn_buf, buf, ret);
1224 avio_w8(dyn_buf, 0);
1227 ret = avio_close_dyn_buf(dyn_buf, &str);
1233 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1236 AVStream *st = ost->st;
1238 if (ost->filters_script && ost->filters) {
1239 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1240 "output stream #%d:%d.\n", nb_output_files, st->index);
1244 if (ost->filters_script)
1245 return read_file(ost->filters_script);
1246 else if (ost->filters)
1247 return av_strdup(ost->filters);
1249 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1253 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1254 const OutputStream *ost, enum AVMediaType type)
1256 if (ost->filters_script || ost->filters) {
1257 av_log(NULL, AV_LOG_ERROR,
1258 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1259 "Filtering and streamcopy cannot be used together.\n",
1260 ost->filters ? "Filtergraph" : "Filtergraph script",
1261 ost->filters ? ost->filters : ost->filters_script,
1262 av_get_media_type_string(type), ost->file_index, ost->index);
1267 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1271 AVCodecContext *video_enc;
1272 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1274 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1276 video_enc = ost->enc_ctx;
1278 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1279 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1280 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1284 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1285 if (frame_aspect_ratio) {
1287 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1288 q.num <= 0 || q.den <= 0) {
1289 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1292 ost->frame_aspect_ratio = q;
1295 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1296 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1298 if (!ost->stream_copy) {
1299 const char *p = NULL;
1300 char *frame_size = NULL;
1301 char *frame_pix_fmt = NULL;
1302 char *intra_matrix = NULL, *inter_matrix = NULL;
1303 char *chroma_intra_matrix = NULL;
1307 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1308 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1309 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1313 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1314 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1315 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1316 ost->keep_pix_fmt = 1;
1317 if (!*++frame_pix_fmt)
1318 frame_pix_fmt = NULL;
1320 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1321 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1324 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1327 video_enc->gop_size = 0;
1328 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1330 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1331 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1334 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1336 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1337 if (chroma_intra_matrix) {
1338 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1340 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1343 av_codec_set_chroma_intra_matrix(video_enc, p);
1344 parse_matrix_coeffs(p, chroma_intra_matrix);
1346 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1348 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1349 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1352 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1355 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1356 for (i = 0; p; i++) {
1358 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1360 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1363 /* FIXME realloc failure */
1364 video_enc->rc_override =
1365 av_realloc(video_enc->rc_override,
1366 sizeof(RcOverride) * (i + 1));
1367 video_enc->rc_override[i].start_frame = start;
1368 video_enc->rc_override[i].end_frame = end;
1370 video_enc->rc_override[i].qscale = q;
1371 video_enc->rc_override[i].quality_factor = 1.0;
1374 video_enc->rc_override[i].qscale = 0;
1375 video_enc->rc_override[i].quality_factor = -q/100.0;
1380 video_enc->rc_override_count = i;
1381 video_enc->intra_dc_precision = intra_dc_precision - 8;
1384 video_enc->flags|= CODEC_FLAG_PSNR;
1387 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1390 video_enc->flags |= CODEC_FLAG_PASS1;
1391 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1394 video_enc->flags |= CODEC_FLAG_PASS2;
1395 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1399 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1400 if (ost->logfile_prefix &&
1401 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1404 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1405 if (ost->forced_keyframes)
1406 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1408 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1410 ost->top_field_first = -1;
1411 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1414 ost->avfilter = get_ost_filters(o, oc, ost);
1418 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1421 if (ost->stream_copy)
1422 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1427 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1432 AVCodecContext *audio_enc;
1434 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1437 audio_enc = ost->enc_ctx;
1438 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1440 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1441 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1443 if (!ost->stream_copy) {
1444 char *sample_fmt = NULL;
1446 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1448 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1450 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1451 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1455 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1457 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1458 ost->apad = av_strdup(ost->apad);
1460 ost->avfilter = get_ost_filters(o, oc, ost);
1464 /* check for channel mapping for this audio stream */
1465 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1466 AudioChannelMap *map = &o->audio_channel_maps[n];
1467 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1468 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1471 if (map->channel_idx == -1) {
1473 } else if (ost->source_index < 0) {
1474 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1475 ost->file_index, ost->st->index);
1478 ist = input_streams[ost->source_index];
1481 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1482 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1483 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1485 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1486 ost->file_index, ost->st->index);
1492 if (ost->stream_copy)
1493 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1498 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1502 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1503 if (!ost->stream_copy) {
1504 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1511 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1513 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1514 ost->stream_copy = 1;
1519 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1523 AVCodecContext *subtitle_enc;
1525 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1527 subtitle_enc = ost->enc_ctx;
1529 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1531 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1533 if (!ost->stream_copy) {
1534 char *frame_size = NULL;
1536 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1537 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1538 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1546 /* arg format is "output-stream-index:streamid-value". */
1547 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1549 OptionsContext *o = optctx;
1554 av_strlcpy(idx_str, arg, sizeof(idx_str));
1555 p = strchr(idx_str, ':');
1557 av_log(NULL, AV_LOG_FATAL,
1558 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1563 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1564 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1565 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1569 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1571 AVFormatContext *is = ifile->ctx;
1572 AVFormatContext *os = ofile->ctx;
1576 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1578 return AVERROR(ENOMEM);
1581 for (i = 0; i < is->nb_chapters; i++) {
1582 AVChapter *in_ch = is->chapters[i], *out_ch;
1583 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1584 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1585 AV_TIME_BASE_Q, in_ch->time_base);
1586 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1587 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1590 if (in_ch->end < ts_off)
1592 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1595 out_ch = av_mallocz(sizeof(AVChapter));
1597 return AVERROR(ENOMEM);
1599 out_ch->id = in_ch->id;
1600 out_ch->time_base = in_ch->time_base;
1601 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1602 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1605 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1607 os->chapters[os->nb_chapters++] = out_ch;
1612 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1615 AVFormatContext *ic = avformat_alloc_context();
1617 ic->interrupt_callback = int_cb;
1618 err = avformat_open_input(&ic, filename, NULL, NULL);
1621 /* copy stream format */
1622 for(i=0;i<ic->nb_streams;i++) {
1626 AVCodecContext *avctx;
1628 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1629 ost = new_output_stream(o, s, codec->type, -1);
1634 // FIXME: a more elegant solution is needed
1635 memcpy(st, ic->streams[i], sizeof(AVStream));
1637 st->info = av_malloc(sizeof(*st->info));
1638 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1640 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1642 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1643 choose_sample_fmt(st, codec);
1644 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1645 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1646 avcodec_copy_context(ost->enc_ctx, st->codec);
1649 avformat_close_input(&ic);
1653 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1654 AVFormatContext *oc)
1658 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1659 ofilter->out_tmp->pad_idx)) {
1660 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1661 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1663 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1668 ost->source_index = -1;
1669 ost->filter = ofilter;
1673 if (ost->stream_copy) {
1674 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1675 "which is fed from a complex filtergraph. Filtering and streamcopy "
1676 "cannot be used together.\n", ost->file_index, ost->index);
1680 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1681 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1682 av_log(NULL, AV_LOG_ERROR,
1683 "%s '%s' was specified through the %s option "
1684 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1685 "%s and -filter_complex cannot be used together for the same stream.\n",
1686 ost->filters ? "Filtergraph" : "Filtergraph script",
1687 ost->filters ? ost->filters : ost->filters_script,
1688 opt, ost->file_index, ost->index, opt);
1692 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1693 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1696 avfilter_inout_free(&ofilter->out_tmp);
1699 static int configure_complex_filters(void)
1703 for (i = 0; i < nb_filtergraphs; i++)
1704 if (!filtergraphs[i]->graph &&
1705 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1710 static int open_output_file(OptionsContext *o, const char *filename)
1712 AVFormatContext *oc;
1714 AVOutputFormat *file_oformat;
1718 AVDictionary *unused_opts = NULL;
1719 AVDictionaryEntry *e = NULL;
1721 if (configure_complex_filters() < 0) {
1722 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1726 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1727 o->stop_time = INT64_MAX;
1728 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1731 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1732 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1733 if (o->stop_time <= start_time) {
1734 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1735 o->stop_time = INT64_MAX;
1737 o->recording_time = o->stop_time - start_time;
1741 GROW_ARRAY(output_files, nb_output_files);
1742 of = av_mallocz(sizeof(*of));
1745 output_files[nb_output_files - 1] = of;
1747 of->ost_index = nb_output_streams;
1748 of->recording_time = o->recording_time;
1749 of->start_time = o->start_time;
1750 of->limit_filesize = o->limit_filesize;
1751 of->shortest = o->shortest;
1752 av_dict_copy(&of->opts, o->g->format_opts, 0);
1754 if (!strcmp(filename, "-"))
1757 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1759 print_error(filename, err);
1764 if (o->recording_time != INT64_MAX)
1765 oc->duration = o->recording_time;
1767 file_oformat= oc->oformat;
1768 oc->interrupt_callback = int_cb;
1770 /* create streams for all unlabeled output pads */
1771 for (i = 0; i < nb_filtergraphs; i++) {
1772 FilterGraph *fg = filtergraphs[i];
1773 for (j = 0; j < fg->nb_outputs; j++) {
1774 OutputFilter *ofilter = fg->outputs[j];
1776 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1779 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1780 ofilter->out_tmp->pad_idx)) {
1781 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1782 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1783 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1785 init_output_filter(ofilter, o, oc);
1789 /* ffserver seeking with date=... needs a date reference */
1790 if (!strcmp(file_oformat->name, "ffm") &&
1791 av_strstart(filename, "http:", NULL)) {
1792 int err = parse_option(o, "metadata", "creation_time=now", options);
1794 print_error(filename, err);
1799 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1800 av_strstart(filename, "http:", NULL)) {
1802 /* special case for files sent to ffserver: we get the stream
1803 parameters from ffserver */
1804 int err = read_ffserver_streams(o, oc, filename);
1806 print_error(filename, err);
1809 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1810 ost = output_streams[j];
1811 for (i = 0; i < nb_input_streams; i++) {
1812 ist = input_streams[i];
1813 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1815 ost->source_index= i;
1816 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1817 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1819 ist->st->discard = ist->user_set_discard;
1824 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1828 } else if (!o->nb_stream_maps) {
1829 char *subtitle_codec_name = NULL;
1830 /* pick the "best" stream of each type */
1832 /* video: highest resolution */
1833 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1834 int area = 0, idx = -1;
1835 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1836 for (i = 0; i < nb_input_streams; i++) {
1838 ist = input_streams[i];
1839 new_area = ist->st->codec->width * ist->st->codec->height;
1840 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1842 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1844 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1851 new_video_stream(o, oc, idx);
1854 /* audio: most channels */
1855 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1856 int channels = 0, idx = -1;
1857 for (i = 0; i < nb_input_streams; i++) {
1858 ist = input_streams[i];
1859 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1860 ist->st->codec->channels > channels) {
1861 channels = ist->st->codec->channels;
1866 new_audio_stream(o, oc, idx);
1869 /* subtitles: pick first */
1870 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1871 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1872 for (i = 0; i < nb_input_streams; i++)
1873 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1874 new_subtitle_stream(o, oc, i);
1878 /* do something with data? */
1880 for (i = 0; i < o->nb_stream_maps; i++) {
1881 StreamMap *map = &o->stream_maps[i];
1886 if (map->linklabel) {
1888 OutputFilter *ofilter = NULL;
1891 for (j = 0; j < nb_filtergraphs; j++) {
1892 fg = filtergraphs[j];
1893 for (k = 0; k < fg->nb_outputs; k++) {
1894 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1895 if (out && !strcmp(out->name, map->linklabel)) {
1896 ofilter = fg->outputs[k];
1903 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1904 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1907 init_output_filter(ofilter, o, oc);
1909 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1911 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1912 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1914 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1916 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1918 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1921 switch (ist->st->codec->codec_type) {
1922 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1923 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1924 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1925 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1926 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1928 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1929 map->file_index, map->stream_index);
1936 /* handle attached files */
1937 for (i = 0; i < o->nb_attachments; i++) {
1939 uint8_t *attachment;
1943 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1944 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1948 if ((len = avio_size(pb)) <= 0) {
1949 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1953 if (!(attachment = av_malloc(len))) {
1954 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1958 avio_read(pb, attachment, len);
1960 ost = new_attachment_stream(o, oc, -1);
1961 ost->stream_copy = 0;
1962 ost->attachment_filename = o->attachments[i];
1964 ost->enc_ctx->extradata = attachment;
1965 ost->enc_ctx->extradata_size = len;
1967 p = strrchr(o->attachments[i], '/');
1968 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1972 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1973 AVDictionaryEntry *e;
1974 ost = output_streams[i];
1976 if ((ost->stream_copy || ost->attachment_filename)
1977 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1978 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1979 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1983 /* check if all codec options have been used */
1984 unused_opts = strip_specifiers(o->g->codec_opts);
1985 for (i = of->ost_index; i < nb_output_streams; i++) {
1987 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1988 AV_DICT_IGNORE_SUFFIX)))
1989 av_dict_set(&unused_opts, e->key, NULL, 0);
1993 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1994 const AVClass *class = avcodec_get_class();
1995 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1996 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1999 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2000 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2001 "output file #%d (%s) is not an encoding option.\n", e->key,
2002 option->help ? option->help : "", nb_output_files - 1,
2007 // gop_timecode is injected by generic code but not always used
2008 if (!strcmp(e->key, "gop_timecode"))
2011 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2012 "output file #%d (%s) has not been used for any stream. The most "
2013 "likely reason is either wrong type (e.g. a video option with "
2014 "no video streams) or that it is a private option of some encoder "
2015 "which was not actually used for any stream.\n", e->key,
2016 option->help ? option->help : "", nb_output_files - 1, filename);
2018 av_dict_free(&unused_opts);
2020 /* check filename in case of an image number is expected */
2021 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2022 if (!av_filename_number_test(oc->filename)) {
2023 print_error(oc->filename, AVERROR(EINVAL));
2028 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2029 /* test if it already exists to avoid losing precious files */
2030 assert_file_overwrite(filename);
2033 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2034 &oc->interrupt_callback,
2036 print_error(filename, err);
2039 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2040 assert_file_overwrite(filename);
2042 if (o->mux_preload) {
2044 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2045 av_dict_set(&of->opts, "preload", buf, 0);
2047 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2050 for (i = 0; i < o->nb_metadata_map; i++) {
2052 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2054 if (in_file_index >= nb_input_files) {
2055 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2058 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2059 in_file_index >= 0 ?
2060 input_files[in_file_index]->ctx : NULL, o);
2064 if (o->chapters_input_file >= nb_input_files) {
2065 if (o->chapters_input_file == INT_MAX) {
2066 /* copy chapters from the first input file that has them*/
2067 o->chapters_input_file = -1;
2068 for (i = 0; i < nb_input_files; i++)
2069 if (input_files[i]->ctx->nb_chapters) {
2070 o->chapters_input_file = i;
2074 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2075 o->chapters_input_file);
2079 if (o->chapters_input_file >= 0)
2080 copy_chapters(input_files[o->chapters_input_file], of,
2081 !o->metadata_chapters_manual);
2083 /* copy global metadata by default */
2084 if (!o->metadata_global_manual && nb_input_files){
2085 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2086 AV_DICT_DONT_OVERWRITE);
2087 if(o->recording_time != INT64_MAX)
2088 av_dict_set(&oc->metadata, "duration", NULL, 0);
2089 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2091 if (!o->metadata_streams_manual)
2092 for (i = of->ost_index; i < nb_output_streams; i++) {
2094 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2096 ist = input_streams[output_streams[i]->source_index];
2097 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2098 if (!output_streams[i]->stream_copy)
2099 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2102 /* process manually set metadata */
2103 for (i = 0; i < o->nb_metadata; i++) {
2106 const char *stream_spec;
2107 int index = 0, j, ret = 0;
2109 val = strchr(o->metadata[i].u.str, '=');
2111 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2112 o->metadata[i].u.str);
2117 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2119 for (j = 0; j < oc->nb_streams; j++) {
2120 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2121 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2132 if (index < 0 || index >= oc->nb_chapters) {
2133 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2136 m = &oc->chapters[index]->metadata;
2139 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2142 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2149 static int opt_target(void *optctx, const char *opt, const char *arg)
2151 OptionsContext *o = optctx;
2152 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2153 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2155 if (!strncmp(arg, "pal-", 4)) {
2158 } else if (!strncmp(arg, "ntsc-", 5)) {
2161 } else if (!strncmp(arg, "film-", 5)) {
2165 /* Try to determine PAL/NTSC by peeking in the input files */
2166 if (nb_input_files) {
2168 for (j = 0; j < nb_input_files; j++) {
2169 for (i = 0; i < input_files[j]->nb_streams; i++) {
2170 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2171 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2173 fr = c->time_base.den * 1000 / c->time_base.num;
2177 } else if ((fr == 29970) || (fr == 23976)) {
2182 if (norm != UNKNOWN)
2186 if (norm != UNKNOWN)
2187 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2190 if (norm == UNKNOWN) {
2191 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2192 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2193 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2197 if (!strcmp(arg, "vcd")) {
2198 opt_video_codec(o, "c:v", "mpeg1video");
2199 opt_audio_codec(o, "c:a", "mp2");
2200 parse_option(o, "f", "vcd", options);
2202 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2203 parse_option(o, "r", frame_rates[norm], options);
2204 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2206 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2208 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2209 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2211 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2212 parse_option(o, "ar", "44100", options);
2213 parse_option(o, "ac", "2", options);
2215 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2216 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2218 /* We have to offset the PTS, so that it is consistent with the SCR.
2219 SCR starts at 36000, but the first two packs contain only padding
2220 and the first pack from the other stream, respectively, may also have
2221 been written before.
2222 So the real data starts at SCR 36000+3*1200. */
2223 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2224 } else if (!strcmp(arg, "svcd")) {
2226 opt_video_codec(o, "c:v", "mpeg2video");
2227 opt_audio_codec(o, "c:a", "mp2");
2228 parse_option(o, "f", "svcd", options);
2230 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2231 parse_option(o, "r", frame_rates[norm], options);
2232 parse_option(o, "pix_fmt", "yuv420p", options);
2233 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2235 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2236 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2237 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2238 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2239 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2241 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2242 parse_option(o, "ar", "44100", options);
2244 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2246 } else if (!strcmp(arg, "dvd")) {
2248 opt_video_codec(o, "c:v", "mpeg2video");
2249 opt_audio_codec(o, "c:a", "ac3");
2250 parse_option(o, "f", "dvd", options);
2252 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2253 parse_option(o, "r", frame_rates[norm], options);
2254 parse_option(o, "pix_fmt", "yuv420p", options);
2255 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2257 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2258 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2259 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2260 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2262 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2263 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2265 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2266 parse_option(o, "ar", "48000", options);
2268 } else if (!strncmp(arg, "dv", 2)) {
2270 parse_option(o, "f", "dv", options);
2272 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2273 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2274 norm == PAL ? "yuv420p" : "yuv411p", options);
2275 parse_option(o, "r", frame_rates[norm], options);
2277 parse_option(o, "ar", "48000", options);
2278 parse_option(o, "ac", "2", options);
2281 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2282 return AVERROR(EINVAL);
2287 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2289 av_free (vstats_filename);
2290 vstats_filename = av_strdup (arg);
2294 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2297 time_t today2 = time(NULL);
2298 struct tm *today = localtime(&today2);
2300 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2302 return opt_vstats_file(NULL, opt, filename);
2305 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2307 OptionsContext *o = optctx;
2308 return parse_option(o, "frames:v", arg, options);
2311 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2313 OptionsContext *o = optctx;
2314 return parse_option(o, "frames:a", arg, options);
2317 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2319 OptionsContext *o = optctx;
2320 return parse_option(o, "frames:d", arg, options);
2323 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2326 AVDictionary *cbak = codec_opts;
2327 AVDictionary *fbak = format_opts;
2331 ret = opt_default(NULL, opt, arg);
2333 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2334 av_dict_copy(&o->g->format_opts, format_opts, 0);
2335 av_dict_free(&codec_opts);
2336 av_dict_free(&format_opts);
2343 static int opt_preset(void *optctx, const char *opt, const char *arg)
2345 OptionsContext *o = optctx;
2347 char filename[1000], line[1000], tmp_line[1000];
2348 const char *codec_name = NULL;
2352 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2354 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2355 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2356 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2358 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2362 while (fgets(line, sizeof(line), f)) {
2363 char *key = tmp_line, *value, *endptr;
2365 if (strcspn(line, "#\n\r") == 0)
2367 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2368 if (!av_strtok(key, "=", &value) ||
2369 !av_strtok(value, "\r\n", &endptr)) {
2370 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2373 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2375 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2376 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2377 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2378 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2379 else if (opt_default_new(o, key, value) < 0) {
2380 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2381 filename, line, key, value);
2391 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2393 OptionsContext *o = optctx;
2394 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2395 int ret = parse_option(o, s, arg, options);
2400 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2402 OptionsContext *o = optctx;
2403 if(!strcmp(opt, "b")){
2404 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2405 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2408 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2412 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2414 OptionsContext *o = optctx;
2417 if(!strcmp(opt, "qscale")){
2418 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2419 return parse_option(o, "q:v", arg, options);
2421 s = av_asprintf("q%s", opt + 6);
2422 ret = parse_option(o, s, arg, options);
2427 static int opt_profile(void *optctx, const char *opt, const char *arg)
2429 OptionsContext *o = optctx;
2430 if(!strcmp(opt, "profile")){
2431 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2432 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2435 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2439 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2441 OptionsContext *o = optctx;
2442 return parse_option(o, "filter:v", arg, options);
2445 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2447 OptionsContext *o = optctx;
2448 return parse_option(o, "filter:a", arg, options);
2451 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2453 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2454 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2455 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2456 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2458 if (video_sync_method == VSYNC_AUTO)
2459 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2463 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2465 OptionsContext *o = optctx;
2466 char *tcr = av_asprintf("timecode=%s", arg);
2467 int ret = parse_option(o, "metadata:g", tcr, options);
2469 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2474 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2476 OptionsContext *o = optctx;
2477 char layout_str[32];
2480 int ret, channels, ac_str_size;
2483 layout = av_get_channel_layout(arg);
2485 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2486 return AVERROR(EINVAL);
2488 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2489 ret = opt_default_new(o, opt, layout_str);
2493 /* set 'ac' option based on channel layout */
2494 channels = av_get_channel_layout_nb_channels(layout);
2495 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2496 stream_str = strchr(opt, ':');
2497 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2498 ac_str = av_mallocz(ac_str_size);
2500 return AVERROR(ENOMEM);
2501 av_strlcpy(ac_str, "ac", 3);
2503 av_strlcat(ac_str, stream_str, ac_str_size);
2504 ret = parse_option(o, ac_str, layout_str, options);
2510 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2512 OptionsContext *o = optctx;
2513 return parse_option(o, "q:a", arg, options);
2516 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2518 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2519 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2520 return AVERROR(ENOMEM);
2521 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2522 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2523 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2524 return AVERROR(ENOMEM);
2528 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2530 uint8_t *graph_desc = read_file(arg);
2532 return AVERROR(EINVAL);
2534 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2535 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2536 return AVERROR(ENOMEM);
2537 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2538 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2542 void show_help_default(const char *opt, const char *arg)
2544 /* per-file options have at least one of those set */
2545 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2546 int show_advanced = 0, show_avoptions = 0;
2549 if (!strcmp(opt, "long"))
2551 else if (!strcmp(opt, "full"))
2552 show_advanced = show_avoptions = 1;
2554 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2559 printf("Getting help:\n"
2560 " -h -- print basic options\n"
2561 " -h long -- print more options\n"
2562 " -h full -- print all options (including all format and codec specific options, very long)\n"
2563 " See man %s for detailed description of the options.\n"
2564 "\n", program_name);
2566 show_help_options(options, "Print help / information / capabilities:",
2569 show_help_options(options, "Global options (affect whole program "
2570 "instead of just one file:",
2571 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2573 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2574 per_file | OPT_EXIT, 0);
2576 show_help_options(options, "Per-file main options:", 0,
2577 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2578 OPT_EXIT, per_file);
2580 show_help_options(options, "Advanced per-file options:",
2581 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2583 show_help_options(options, "Video options:",
2584 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2586 show_help_options(options, "Advanced Video options:",
2587 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2589 show_help_options(options, "Audio options:",
2590 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2592 show_help_options(options, "Advanced Audio options:",
2593 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2594 show_help_options(options, "Subtitle options:",
2595 OPT_SUBTITLE, 0, 0);
2598 if (show_avoptions) {
2599 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2600 show_help_children(avcodec_get_class(), flags);
2601 show_help_children(avformat_get_class(), flags);
2603 show_help_children(sws_get_class(), flags);
2605 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2606 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2610 void show_usage(void)
2612 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2613 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2614 av_log(NULL, AV_LOG_INFO, "\n");
2622 static const OptionGroupDef groups[] = {
2623 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2624 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2627 static int open_files(OptionGroupList *l, const char *inout,
2628 int (*open_file)(OptionsContext*, const char*))
2632 for (i = 0; i < l->nb_groups; i++) {
2633 OptionGroup *g = &l->groups[i];
2639 ret = parse_optgroup(&o, g);
2641 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2642 "%s.\n", inout, g->arg);
2646 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2647 ret = open_file(&o, g->arg);
2650 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2654 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2660 int ffmpeg_parse_options(int argc, char **argv)
2662 OptionParseContext octx;
2666 memset(&octx, 0, sizeof(octx));
2668 /* split the commandline into an internal representation */
2669 ret = split_commandline(&octx, argc, argv, options, groups,
2670 FF_ARRAY_ELEMS(groups));
2672 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2676 /* apply global options */
2677 ret = parse_optgroup(NULL, &octx.global_opts);
2679 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2683 /* open input files */
2684 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2686 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2690 /* open output files */
2691 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2693 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2698 uninit_parse_context(&octx);
2700 av_strerror(ret, error, sizeof(error));
2701 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2706 static int opt_progress(void *optctx, const char *opt, const char *arg)
2708 AVIOContext *avio = NULL;
2711 if (!strcmp(arg, "-"))
2713 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2715 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2716 arg, av_err2str(ret));
2719 progress_avio = avio;
2723 #define OFFSET(x) offsetof(OptionsContext, x)
2724 const OptionDef options[] = {
2726 #include "cmdutils_common_opts.h"
2727 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2729 "force format", "fmt" },
2730 { "y", OPT_BOOL, { &file_overwrite },
2731 "overwrite output files" },
2732 { "n", OPT_BOOL, { &no_file_overwrite },
2733 "never overwrite output files" },
2734 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2735 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2736 "codec name", "codec" },
2737 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2738 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2739 "codec name", "codec" },
2740 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2741 OPT_OUTPUT, { .off = OFFSET(presets) },
2742 "preset name", "preset" },
2743 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2744 OPT_OUTPUT, { .func_arg = opt_map },
2745 "set input stream mapping",
2746 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2747 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2748 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2749 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2750 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2751 "set metadata information of outfile from infile",
2752 "outfile[,metadata]:infile[,metadata]" },
2753 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2754 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2755 "set chapters mapping", "input_file_index" },
2756 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2757 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2758 "record or transcode \"duration\" seconds of audio/video",
2760 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2761 "record or transcode stop time", "time_stop" },
2762 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2763 "set the limit file size in bytes", "limit_size" },
2764 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2765 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2766 "set the start time offset", "time_off" },
2767 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2768 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2769 "enable/disable accurate seeking with -ss" },
2770 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2771 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2772 "set the input ts offset", "time_off" },
2773 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2774 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2775 "set the input ts scale", "scale" },
2776 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2777 "set the recording timestamp ('now' to set the current time)", "time" },
2778 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2779 "add metadata", "string=string" },
2780 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2781 OPT_OUTPUT, { .func_arg = opt_data_frames },
2782 "set the number of data frames to record", "number" },
2783 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2784 "add timings for benchmarking" },
2785 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2786 "add timings for each task" },
2787 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2788 "write program-readable progress information", "url" },
2789 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2790 "enable or disable interaction on standard input" },
2791 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2792 "set max runtime in seconds", "limit" },
2793 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2794 "dump each input packet" },
2795 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2796 "when dumping packets, also dump the payload" },
2797 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2798 OPT_INPUT, { .off = OFFSET(rate_emu) },
2799 "read input at native frame rate", "" },
2800 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2801 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2802 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2803 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2804 "video sync method", "" },
2805 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2806 "audio sync method", "" },
2807 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2808 "audio drift threshold", "threshold" },
2809 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2810 "copy timestamps" },
2811 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2812 "copy input stream time base when stream copying", "mode" },
2813 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2814 OPT_OUTPUT, { .off = OFFSET(shortest) },
2815 "finish encoding within shortest input" },
2816 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2817 OPT_OUTPUT, { .off = OFFSET(apad) },
2819 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2820 "timestamp discontinuity delta threshold", "threshold" },
2821 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2822 "timestamp error delta threshold", "threshold" },
2823 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2824 "exit on error", "error" },
2825 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2826 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2827 "copy initial non-keyframes" },
2828 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2829 "copy or discard frames before start time" },
2830 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2831 "set the number of frames to record", "number" },
2832 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2833 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2834 "force codec tag/fourcc", "fourcc/tag" },
2835 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2836 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2837 "use fixed quality scale (VBR)", "q" },
2838 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2839 OPT_OUTPUT, { .func_arg = opt_qscale },
2840 "use fixed quality scale (VBR)", "q" },
2841 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2842 "set profile", "profile" },
2843 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2844 "set stream filtergraph", "filter_graph" },
2845 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2846 "read stream filtergraph description from a file", "filename" },
2847 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2848 "reinit filtergraph on input parameter changes", "" },
2849 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2850 "create a complex filtergraph", "graph_description" },
2851 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2852 "create a complex filtergraph", "graph_description" },
2853 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2854 "read complex filtergraph description from a file", "filename" },
2855 { "stats", OPT_BOOL, { &print_stats },
2856 "print progress report during encoding", },
2857 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2858 OPT_OUTPUT, { .func_arg = opt_attach },
2859 "add an attachment to the output file", "filename" },
2860 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2861 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2862 "extract an attachment into a file", "filename" },
2863 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2864 "print timestamp debugging info" },
2865 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2866 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2867 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2868 OPT_INPUT, { .off = OFFSET(discard) },
2872 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2873 "set the number of video frames to record", "number" },
2874 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2875 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2876 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2877 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2878 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2879 "set frame size (WxH or abbreviation)", "size" },
2880 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2881 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2882 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2883 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2884 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2885 "set pixel format", "format" },
2886 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2887 "set the number of bits per raw sample", "number" },
2888 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2889 "deprecated use -g 1" },
2890 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2892 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2893 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2894 "rate control override for specific intervals", "override" },
2895 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2896 OPT_OUTPUT, { .func_arg = opt_video_codec },
2897 "force video codec ('copy' to copy stream)", "codec" },
2898 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2900 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2902 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2903 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2904 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2905 "select the pass number (1 to 3)", "n" },
2906 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2907 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2908 "select two pass log file name prefix", "prefix" },
2909 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2910 "this option is deprecated, use the yadif filter instead" },
2911 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2912 "calculate PSNR of compressed frames" },
2913 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2914 "dump video coding statistics to file" },
2915 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2916 "dump video coding statistics to file", "file" },
2917 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2918 "set video filters", "filter_graph" },
2919 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2920 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2921 "specify intra matrix coeffs", "matrix" },
2922 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2923 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2924 "specify inter matrix coeffs", "matrix" },
2925 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2926 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2927 "specify intra matrix coeffs", "matrix" },
2928 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2929 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2930 "top=1/bottom=0/auto=-1 field first", "" },
2931 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2932 "intra_dc_precision", "precision" },
2933 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2934 OPT_OUTPUT, { .func_arg = opt_old2new },
2935 "force video tag/fourcc", "fourcc/tag" },
2936 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2937 "show QP histogram" },
2938 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2939 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2940 "force the selected framerate, disable the best supported framerate selection" },
2941 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2942 OPT_OUTPUT, { .func_arg = opt_streamid },
2943 "set the value of an outfile streamid", "streamIndex:value" },
2944 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2945 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2946 "force key frames at specified timestamps", "timestamps" },
2947 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2948 "video bitrate (please use -b:v)", "bitrate" },
2949 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2950 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2951 "use HW accelerated decoding", "hwaccel name" },
2952 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2953 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2954 "select a device for HW acceleration" "devicename" },
2957 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2958 "set the number of audio frames to record", "number" },
2959 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2960 "set audio quality (codec-specific)", "quality", },
2961 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2962 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2963 "set audio sampling rate (in Hz)", "rate" },
2964 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2965 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2966 "set number of audio channels", "channels" },
2967 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2969 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2970 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2971 "force audio codec ('copy' to copy stream)", "codec" },
2972 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2973 OPT_OUTPUT, { .func_arg = opt_old2new },
2974 "force audio tag/fourcc", "fourcc/tag" },
2975 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2976 "change audio volume (256=normal)" , "volume" },
2977 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2978 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2979 "set sample format", "format" },
2980 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2981 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2982 "set channel layout", "layout" },
2983 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2984 "set audio filters", "filter_graph" },
2985 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2986 "set the maximum number of channels to try to guess the channel layout" },
2988 /* subtitle options */
2989 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2990 "disable subtitle" },
2991 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2992 "force subtitle codec ('copy' to copy stream)", "codec" },
2993 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2994 , "force subtitle tag/fourcc", "fourcc/tag" },
2995 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2996 "fix subtitles duration" },
2997 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2998 "set canvas size (WxH or abbreviation)", "size" },
3001 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3002 "deprecated, use -channel", "channel" },
3003 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3004 "deprecated, use -standard", "standard" },
3005 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3008 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3009 "set the maximum demux-decode delay", "seconds" },
3010 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3011 "set the initial demux-decode delay", "seconds" },
3012 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3013 "override the options from ffserver", "" },
3015 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3016 "A comma-separated list of bitstream filters", "bitstream_filters" },
3017 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3018 "deprecated", "audio bitstream_filters" },
3019 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3020 "deprecated", "video bitstream_filters" },
3022 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3023 "set the audio options to the indicated preset", "preset" },
3024 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3025 "set the video options to the indicated preset", "preset" },
3026 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3027 "set the subtitle options to the indicated preset", "preset" },
3028 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3029 "set options from indicated preset file", "filename" },
3030 /* data codec support */
3031 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3032 "force data codec ('copy' to copy stream)", "codec" },
3033 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },