2 * avconv option parsing
4 * This file is part of Libav.
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 const HWAccel hwaccels[] = {
60 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
63 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
66 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
69 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
72 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
76 int hwaccel_lax_profile_check = 0;
77 AVBufferRef *hw_device_ctx;
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
84 int audio_volume = 256;
85 int audio_sync_method = 0;
86 int video_sync_method = VSYNC_AUTO;
92 int exit_on_error = 0;
96 static int file_overwrite = 0;
97 static int file_skip = 0;
98 static int video_discard = 0;
99 static int intra_dc_precision = 8;
100 static int using_stdin = 0;
101 static int input_sync;
103 static void uninit_options(OptionsContext *o)
105 const OptionDef *po = options;
108 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
110 void *dst = (uint8_t*)o + po->u.off;
112 if (po->flags & OPT_SPEC) {
113 SpecifierOpt **so = dst;
114 int i, *count = (int*)(so + 1);
115 for (i = 0; i < *count; i++) {
116 av_freep(&(*so)[i].specifier);
117 if (po->flags & OPT_STRING)
118 av_freep(&(*so)[i].u.str);
122 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
127 for (i = 0; i < o->nb_stream_maps; i++)
128 av_freep(&o->stream_maps[i].linklabel);
129 av_freep(&o->stream_maps);
130 av_freep(&o->meta_data_maps);
131 av_freep(&o->streamid_map);
134 static void init_options(OptionsContext *o)
136 memset(o, 0, sizeof(*o));
138 o->mux_max_delay = 0.7;
139 o->start_time = AV_NOPTS_VALUE;
140 o->recording_time = INT64_MAX;
141 o->limit_filesize = UINT64_MAX;
142 o->chapters_input_file = INT_MAX;
143 o->accurate_seek = 1;
146 /* return a copy of the input with the stream specifiers removed from the keys */
147 static AVDictionary *strip_specifiers(AVDictionary *dict)
149 AVDictionaryEntry *e = NULL;
150 AVDictionary *ret = NULL;
152 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
153 char *p = strchr(e->key, ':');
157 av_dict_set(&ret, e->key, e->value, 0);
164 static double parse_frame_aspect_ratio(const char *arg)
171 p = strchr(arg, ':');
173 x = strtol(arg, &end, 10);
175 y = strtol(end + 1, &end, 10);
177 ar = (double)x / (double)y;
179 ar = strtod(arg, NULL);
182 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
188 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
192 printf("Supported hardware acceleration:\n");
193 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
194 printf("%s\n", hwaccels[i].name);
200 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
202 OptionsContext *o = optctx;
203 return parse_option(o, "codec:a", arg, options);
206 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
208 OptionsContext *o = optctx;
209 return parse_option(o, "codec:v", arg, options);
212 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
214 OptionsContext *o = optctx;
215 return parse_option(o, "codec:s", arg, options);
218 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
220 OptionsContext *o = optctx;
221 return parse_option(o, "codec:d", arg, options);
224 static int opt_map(void *optctx, const char *opt, const char *arg)
226 OptionsContext *o = optctx;
228 int i, negative = 0, file_idx;
229 int sync_file_idx = -1, sync_stream_idx;
237 map = av_strdup(arg);
239 return AVERROR(ENOMEM);
241 /* parse sync stream first, just pick first matching stream */
242 if (sync = strchr(map, ',')) {
244 sync_file_idx = strtol(sync + 1, &sync, 0);
245 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
246 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
251 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
252 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
253 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
257 if (i == input_files[sync_file_idx]->nb_streams) {
258 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
259 "match any streams.\n", arg);
266 /* this mapping refers to lavfi output */
267 const char *c = map + 1;
268 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
269 m = &o->stream_maps[o->nb_stream_maps - 1];
270 m->linklabel = av_get_token(&c, "]");
272 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
276 file_idx = strtol(map, &p, 0);
277 if (file_idx >= nb_input_files || file_idx < 0) {
278 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
282 /* disable some already defined maps */
283 for (i = 0; i < o->nb_stream_maps; i++) {
284 m = &o->stream_maps[i];
285 if (file_idx == m->file_index &&
286 check_stream_specifier(input_files[m->file_index]->ctx,
287 input_files[m->file_index]->ctx->streams[m->stream_index],
288 *p == ':' ? p + 1 : p) > 0)
292 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
293 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
294 *p == ':' ? p + 1 : p) <= 0)
296 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
297 m = &o->stream_maps[o->nb_stream_maps - 1];
299 m->file_index = file_idx;
302 if (sync_file_idx >= 0) {
303 m->sync_file_index = sync_file_idx;
304 m->sync_stream_index = sync_stream_idx;
306 m->sync_file_index = file_idx;
307 m->sync_stream_index = i;
313 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
321 static int opt_attach(void *optctx, const char *opt, const char *arg)
323 OptionsContext *o = optctx;
324 GROW_ARRAY(o->attachments, o->nb_attachments);
325 o->attachments[o->nb_attachments - 1] = arg;
330 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
333 err = vaapi_device_init(arg);
341 * Parse a metadata specifier passed as 'arg' parameter.
342 * @param arg metadata string to parse
343 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
344 * @param index for type c/p, chapter/program index is written here
345 * @param stream_spec for type s, the stream specifier is written here
347 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
355 if (*(++arg) && *arg != ':') {
356 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
359 *stream_spec = *arg == ':' ? arg + 1 : "";
364 *index = strtol(++arg, NULL, 0);
367 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
374 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
376 AVDictionary **meta_in = NULL;
377 AVDictionary **meta_out;
379 char type_in, type_out;
380 const char *istream_spec = NULL, *ostream_spec = NULL;
381 int idx_in = 0, idx_out = 0;
383 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
384 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
386 if (type_in == 'g' || type_out == 'g')
387 o->metadata_global_manual = 1;
388 if (type_in == 's' || type_out == 's')
389 o->metadata_streams_manual = 1;
390 if (type_in == 'c' || type_out == 'c')
391 o->metadata_chapters_manual = 1;
393 /* ic is NULL when just disabling automatic mappings */
397 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
398 if ((index) < 0 || (index) >= (nb_elems)) {\
399 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
404 #define SET_DICT(type, meta, context, index)\
407 meta = &context->metadata;\
410 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
411 meta = &context->chapters[index]->metadata;\
414 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
415 meta = &context->programs[index]->metadata;\
418 break; /* handled separately below */ \
419 default: av_assert0(0);\
422 SET_DICT(type_in, meta_in, ic, idx_in);
423 SET_DICT(type_out, meta_out, oc, idx_out);
425 /* for input streams choose first matching stream */
426 if (type_in == 's') {
427 for (i = 0; i < ic->nb_streams; i++) {
428 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
429 meta_in = &ic->streams[i]->metadata;
435 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
440 if (type_out == 's') {
441 for (i = 0; i < oc->nb_streams; i++) {
442 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
443 meta_out = &oc->streams[i]->metadata;
444 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
449 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
454 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
456 const AVCodecDescriptor *desc;
457 const char *codec_string = encoder ? "encoder" : "decoder";
461 avcodec_find_encoder_by_name(name) :
462 avcodec_find_decoder_by_name(name);
464 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
465 codec = encoder ? avcodec_find_encoder(desc->id) :
466 avcodec_find_decoder(desc->id);
468 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
469 codec_string, codec->name, desc->name);
473 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
476 if (codec->type != type) {
477 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
483 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
485 char *codec_name = NULL;
487 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
489 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
490 st->codecpar->codec_id = codec->id;
493 return avcodec_find_decoder(st->codecpar->codec_id);
496 /* Add all the streams from the given input file to the global
497 * list of input streams. */
498 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
502 for (i = 0; i < ic->nb_streams; i++) {
503 AVStream *st = ic->streams[i];
504 AVCodecParameters *par = st->codecpar;
505 InputStream *ist = av_mallocz(sizeof(*ist));
506 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
507 char *hwaccel_output_format = NULL;
508 char *codec_tag = NULL;
514 GROW_ARRAY(input_streams, nb_input_streams);
515 input_streams[nb_input_streams - 1] = ist;
518 ist->file_index = nb_input_files;
520 st->discard = AVDISCARD_ALL;
522 ist->min_pts = INT64_MAX;
523 ist->max_pts = INT64_MIN;
526 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
529 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
531 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
533 uint32_t tag = strtol(codec_tag, &next, 0);
535 tag = AV_RL32(codec_tag);
536 st->codecpar->codec_tag = tag;
539 ist->dec = choose_decoder(o, ic, st);
540 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
542 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
544 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
548 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
550 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
554 switch (par->codec_type) {
555 case AVMEDIA_TYPE_VIDEO:
556 ist->resample_height = ist->dec_ctx->height;
557 ist->resample_width = ist->dec_ctx->width;
558 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
560 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
561 if (framerate && av_parse_video_rate(&ist->framerate,
563 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
568 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
570 if (!strcmp(hwaccel, "none"))
571 ist->hwaccel_id = HWACCEL_NONE;
572 else if (!strcmp(hwaccel, "auto"))
573 ist->hwaccel_id = HWACCEL_AUTO;
576 for (i = 0; hwaccels[i].name; i++) {
577 if (!strcmp(hwaccels[i].name, hwaccel)) {
578 ist->hwaccel_id = hwaccels[i].id;
583 if (!ist->hwaccel_id) {
584 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
586 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
587 for (i = 0; hwaccels[i].name; i++)
588 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
589 av_log(NULL, AV_LOG_FATAL, "\n");
595 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
596 if (hwaccel_device) {
597 ist->hwaccel_device = av_strdup(hwaccel_device);
598 if (!ist->hwaccel_device)
602 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
603 hwaccel_output_format, ic, st);
604 if (hwaccel_output_format) {
605 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
606 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
607 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
608 "format: %s", hwaccel_output_format);
611 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
614 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
617 case AVMEDIA_TYPE_AUDIO:
618 guess_input_channel_layout(ist);
620 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
621 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
622 ist->resample_channels = ist->dec_ctx->channels;
623 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
626 case AVMEDIA_TYPE_DATA:
627 case AVMEDIA_TYPE_SUBTITLE:
628 case AVMEDIA_TYPE_ATTACHMENT:
629 case AVMEDIA_TYPE_UNKNOWN:
637 static void assert_file_overwrite(const char *filename)
639 if (file_overwrite && file_skip) {
640 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
644 if (!file_overwrite &&
645 (!strchr(filename, ':') || filename[1] == ':' ||
646 av_strstart(filename, "file:", NULL))) {
647 if (avio_check(filename, 0) == 0) {
648 if (!using_stdin && !file_skip) {
649 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
652 fprintf(stderr, "Not overwriting - exiting\n");
657 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
664 static void dump_attachment(AVStream *st, const char *filename)
667 AVIOContext *out = NULL;
668 AVDictionaryEntry *e;
670 if (!st->codecpar->extradata_size) {
671 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
672 nb_input_files - 1, st->index);
675 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
678 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
679 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
683 assert_file_overwrite(filename);
685 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
686 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
691 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
696 static int open_input_file(OptionsContext *o, const char *filename)
700 AVInputFormat *file_iformat = NULL;
705 AVDictionary *unused_opts = NULL;
706 AVDictionaryEntry *e = NULL;
707 int orig_nb_streams; // number of streams before avformat_find_stream_info
710 if (!(file_iformat = av_find_input_format(o->format))) {
711 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
716 if (!strcmp(filename, "-"))
719 using_stdin |= !strncmp(filename, "pipe:", 5) ||
720 !strcmp(filename, "/dev/stdin");
722 /* get default parameters from command line */
723 ic = avformat_alloc_context();
725 print_error(filename, AVERROR(ENOMEM));
728 if (o->nb_audio_sample_rate) {
729 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
730 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
732 if (o->nb_audio_channels) {
733 /* because we set audio_channels based on both the "ac" and
734 * "channel_layout" options, we need to check that the specified
735 * demuxer actually has the "channels" option before setting it */
736 if (file_iformat && file_iformat->priv_class &&
737 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
738 AV_OPT_SEARCH_FAKE_OBJ)) {
739 snprintf(buf, sizeof(buf), "%d",
740 o->audio_channels[o->nb_audio_channels - 1].u.i);
741 av_dict_set(&o->g->format_opts, "channels", buf, 0);
744 if (o->nb_frame_rates) {
745 /* set the format-level framerate option;
746 * this is important for video grabbers, e.g. x11 */
747 if (file_iformat && file_iformat->priv_class &&
748 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
749 AV_OPT_SEARCH_FAKE_OBJ)) {
750 av_dict_set(&o->g->format_opts, "framerate",
751 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
754 if (o->nb_frame_sizes) {
755 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
757 if (o->nb_frame_pix_fmts)
758 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
760 ic->flags |= AVFMT_FLAG_NONBLOCK;
761 ic->interrupt_callback = int_cb;
763 /* open the input file with generic Libav function */
764 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
766 print_error(filename, err);
769 assert_avoptions(o->g->format_opts);
771 /* apply forced codec ids */
772 for (i = 0; i < ic->nb_streams; i++)
773 choose_decoder(o, ic, ic->streams[i]);
775 /* Set AVCodecContext options for avformat_find_stream_info */
776 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
777 orig_nb_streams = ic->nb_streams;
779 /* If not enough info to get the stream parameters, we decode the
780 first frames to get it. (used in mpeg case for example) */
781 ret = avformat_find_stream_info(ic, opts);
783 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
784 avformat_close_input(&ic);
788 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
789 /* add the stream start time */
790 if (ic->start_time != AV_NOPTS_VALUE)
791 timestamp += ic->start_time;
793 /* if seeking requested, we execute it */
794 if (o->start_time != AV_NOPTS_VALUE) {
795 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
797 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
798 filename, (double)timestamp / AV_TIME_BASE);
802 /* update the current parameters so that they match the one of the input stream */
803 add_input_streams(o, ic);
805 /* dump the file content */
806 av_dump_format(ic, nb_input_files, filename, 0);
808 GROW_ARRAY(input_files, nb_input_files);
809 f = av_mallocz(sizeof(*f));
812 input_files[nb_input_files - 1] = f;
815 f->ist_index = nb_input_streams - ic->nb_streams;
816 f->start_time = o->start_time;
817 f->recording_time = o->recording_time;
818 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
819 f->nb_streams = ic->nb_streams;
820 f->rate_emu = o->rate_emu;
821 f->accurate_seek = o->accurate_seek;
824 f->time_base = (AVRational){ 1, 1 };
826 /* check if all codec options have been used */
827 unused_opts = strip_specifiers(o->g->codec_opts);
828 for (i = f->ist_index; i < nb_input_streams; i++) {
830 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
831 AV_DICT_IGNORE_SUFFIX)))
832 av_dict_set(&unused_opts, e->key, NULL, 0);
836 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
837 const AVClass *class = avcodec_get_class();
838 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
839 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
842 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
843 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
844 "input file #%d (%s) is not a decoding option.\n", e->key,
845 option->help ? option->help : "", nb_input_files - 1,
850 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
851 "input file #%d (%s) has not been used for any stream. The most "
852 "likely reason is either wrong type (e.g. a video option with "
853 "no video streams) or that it is a private option of some decoder "
854 "which was not actually used for any stream.\n", e->key,
855 option->help ? option->help : "", nb_input_files - 1, filename);
857 av_dict_free(&unused_opts);
859 for (i = 0; i < o->nb_dump_attachment; i++) {
862 for (j = 0; j < ic->nb_streams; j++) {
863 AVStream *st = ic->streams[j];
865 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
866 dump_attachment(st, o->dump_attachment[i].u.str);
870 for (i = 0; i < orig_nb_streams; i++)
871 av_dict_free(&opts[i]);
877 static uint8_t *get_line(AVIOContext *s)
883 if (avio_open_dyn_buf(&line) < 0) {
884 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
888 while ((c = avio_r8(s)) && c != '\n')
891 avio_close_dyn_buf(line, &buf);
896 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
900 const char *base[3] = { getenv("AVCONV_DATADIR"),
905 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
909 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
910 i != 1 ? "" : "/.avconv", codec_name, preset_name);
911 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
914 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
915 i != 1 ? "" : "/.avconv", preset_name);
916 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
922 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
924 enum AVMediaType type = ost->st->codecpar->codec_type;
925 char *codec_name = NULL;
927 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
928 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
930 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
931 NULL, ost->st->codecpar->codec_type);
932 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
934 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
935 "output stream #%d:%d. Default encoder for format %s is "
936 "probably disabled. Please choose an encoder manually.\n",
937 ost->file_index, ost->index, s->oformat->name);
938 return AVERROR_ENCODER_NOT_FOUND;
940 } else if (!strcmp(codec_name, "copy"))
941 ost->stream_copy = 1;
943 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
944 ost->st->codecpar->codec_id = ost->enc->id;
947 ost->encoding_needed = !ost->stream_copy;
949 /* no encoding supported for other media types */
950 ost->stream_copy = 1;
951 ost->encoding_needed = 0;
957 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
960 AVStream *st = avformat_new_stream(oc, NULL);
961 int idx = oc->nb_streams - 1, ret = 0;
962 const char *bsfs = NULL;
963 char *next, *codec_tag = NULL;
967 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
971 if (oc->nb_streams - 1 < o->nb_streamid_map)
972 st->id = o->streamid_map[oc->nb_streams - 1];
974 GROW_ARRAY(output_streams, nb_output_streams);
975 if (!(ost = av_mallocz(sizeof(*ost))))
977 output_streams[nb_output_streams - 1] = ost;
979 ost->file_index = nb_output_files - 1;
982 st->codecpar->codec_type = type;
984 ret = choose_encoder(o, oc, ost);
986 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
987 "%d:%d\n", ost->file_index, ost->index);
991 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
993 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
996 ost->enc_ctx->codec_type = type;
999 AVIOContext *s = NULL;
1000 char *buf = NULL, *arg = NULL, *preset = NULL;
1002 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1004 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1005 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1008 if (!buf[0] || buf[0] == '#') {
1012 if (!(arg = strchr(buf, '='))) {
1013 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1017 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1019 } while (!s->eof_reached);
1023 av_log(NULL, AV_LOG_FATAL,
1024 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1025 preset, ost->file_index, ost->index);
1029 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1032 ost->max_frames = INT64_MAX;
1033 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1035 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1036 while (bsfs && *bsfs) {
1037 const AVBitStreamFilter *filter;
1040 bsf = av_get_token(&bsfs, ",");
1044 filter = av_bsf_get_by_name(bsf);
1046 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1051 ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
1052 ost->nb_bitstream_filters + 1,
1053 sizeof(*ost->bitstream_filters));
1054 if (!ost->bitstream_filters)
1057 ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
1062 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1064 uint32_t tag = strtol(codec_tag, &next, 0);
1066 tag = AV_RL32(codec_tag);
1067 ost->enc_ctx->codec_tag = tag;
1070 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1072 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1073 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1076 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1077 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1079 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1081 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1083 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1084 ost->last_mux_dts = AV_NOPTS_VALUE;
1089 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1092 const char *p = str;
1099 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1106 /* read file contents into a string */
1107 static uint8_t *read_file(const char *filename)
1109 AVIOContext *pb = NULL;
1110 AVIOContext *dyn_buf = NULL;
1111 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1112 uint8_t buf[1024], *str;
1115 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1119 ret = avio_open_dyn_buf(&dyn_buf);
1124 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1125 avio_write(dyn_buf, buf, ret);
1126 avio_w8(dyn_buf, 0);
1129 ret = avio_close_dyn_buf(dyn_buf, &str);
1135 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1138 AVStream *st = ost->st;
1139 char *filter = NULL, *filter_script = NULL;
1141 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1142 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1144 if (filter_script && filter) {
1145 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1146 "output stream #%d:%d.\n", nb_output_files, st->index);
1151 return read_file(filter_script);
1153 return av_strdup(filter);
1155 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1159 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1163 AVCodecContext *video_enc;
1164 char *frame_aspect_ratio = NULL;
1166 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1168 video_enc = ost->enc_ctx;
1170 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1171 if (frame_aspect_ratio)
1172 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1174 if (!ost->stream_copy) {
1175 const char *p = NULL;
1176 char *frame_rate = NULL, *frame_size = NULL;
1177 char *frame_pix_fmt = NULL;
1178 char *intra_matrix = NULL, *inter_matrix = NULL;
1182 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1183 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1184 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1188 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1189 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1190 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1194 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1195 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1196 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1199 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1201 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1203 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1204 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1207 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1209 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1211 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1212 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1215 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1218 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1219 for (i = 0; p; i++) {
1221 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1223 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1226 video_enc->rc_override =
1227 av_realloc(video_enc->rc_override,
1228 sizeof(RcOverride) * (i + 1));
1229 if (!video_enc->rc_override) {
1230 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1233 video_enc->rc_override[i].start_frame = start;
1234 video_enc->rc_override[i].end_frame = end;
1236 video_enc->rc_override[i].qscale = q;
1237 video_enc->rc_override[i].quality_factor = 1.0;
1240 video_enc->rc_override[i].qscale = 0;
1241 video_enc->rc_override[i].quality_factor = -q/100.0;
1246 video_enc->rc_override_count = i;
1247 video_enc->intra_dc_precision = intra_dc_precision - 8;
1250 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1253 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1255 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1259 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1260 if (ost->logfile_prefix &&
1261 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1265 char logfilename[1024];
1268 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1269 ost->logfile_prefix ? ost->logfile_prefix :
1270 DEFAULT_PASS_LOGFILENAME_PREFIX,
1272 if (!strcmp(ost->enc->name, "libx264")) {
1273 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1275 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1276 f = fopen(logfilename, "wb");
1278 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1279 logfilename, strerror(errno));
1284 char *logbuffer = read_file(logfilename);
1287 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1291 video_enc->stats_in = logbuffer;
1296 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1297 if (ost->forced_keyframes)
1298 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1300 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1302 ost->top_field_first = -1;
1303 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1306 ost->avfilter = get_ost_filters(o, oc, ost);
1310 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1316 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1320 AVCodecContext *audio_enc;
1322 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1325 audio_enc = ost->enc_ctx;
1326 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1328 if (!ost->stream_copy) {
1329 char *sample_fmt = NULL;
1331 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1333 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1335 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1336 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1340 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1342 ost->avfilter = get_ost_filters(o, oc, ost);
1350 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1354 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1355 if (!ost->stream_copy) {
1356 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1363 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1365 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1366 ost->stream_copy = 1;
1371 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1374 AVCodecContext *subtitle_enc;
1376 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1377 subtitle_enc = ost->enc_ctx;
1379 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1384 /* arg format is "output-stream-index:streamid-value". */
1385 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1387 OptionsContext *o = optctx;
1392 av_strlcpy(idx_str, arg, sizeof(idx_str));
1393 p = strchr(idx_str, ':');
1395 av_log(NULL, AV_LOG_FATAL,
1396 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1401 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1402 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1403 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1407 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1409 AVFormatContext *is = ifile->ctx;
1410 AVFormatContext *os = ofile->ctx;
1414 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1416 return AVERROR(ENOMEM);
1419 for (i = 0; i < is->nb_chapters; i++) {
1420 AVChapter *in_ch = is->chapters[i], *out_ch;
1421 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1422 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1423 AV_TIME_BASE_Q, in_ch->time_base);
1424 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1425 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1428 if (in_ch->end < ts_off)
1430 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1433 out_ch = av_mallocz(sizeof(AVChapter));
1435 return AVERROR(ENOMEM);
1437 out_ch->id = in_ch->id;
1438 out_ch->time_base = in_ch->time_base;
1439 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1440 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1443 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1445 os->chapters[os->nb_chapters++] = out_ch;
1450 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1451 AVFormatContext *oc)
1455 switch (ofilter->type) {
1456 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1457 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1459 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1464 ost->source_index = -1;
1465 ost->filter = ofilter;
1469 if (ost->stream_copy) {
1470 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1471 "which is fed from a complex filtergraph. Filtering and streamcopy "
1472 "cannot be used together.\n", ost->file_index, ost->index);
1476 avfilter_inout_free(&ofilter->out_tmp);
1479 static int init_complex_filters(void)
1483 for (i = 0; i < nb_filtergraphs; i++) {
1484 ret = init_complex_filtergraph(filtergraphs[i]);
1491 static int configure_complex_filters(void)
1495 for (i = 0; i < nb_filtergraphs; i++)
1496 if (!filtergraph_is_simple(filtergraphs[i]) &&
1497 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1502 static int open_output_file(OptionsContext *o, const char *filename)
1504 AVFormatContext *oc;
1506 AVOutputFormat *file_oformat;
1510 AVDictionary *unused_opts = NULL;
1511 AVDictionaryEntry *e = NULL;
1513 GROW_ARRAY(output_files, nb_output_files);
1514 of = av_mallocz(sizeof(*of));
1517 output_files[nb_output_files - 1] = of;
1519 of->ost_index = nb_output_streams;
1520 of->recording_time = o->recording_time;
1521 of->start_time = o->start_time;
1522 of->limit_filesize = o->limit_filesize;
1523 of->shortest = o->shortest;
1524 av_dict_copy(&of->opts, o->g->format_opts, 0);
1526 if (!strcmp(filename, "-"))
1529 oc = avformat_alloc_context();
1531 print_error(filename, AVERROR(ENOMEM));
1535 if (o->recording_time != INT64_MAX)
1536 oc->duration = o->recording_time;
1539 file_oformat = av_guess_format(o->format, NULL, NULL);
1540 if (!file_oformat) {
1541 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1545 file_oformat = av_guess_format(NULL, filename, NULL);
1546 if (!file_oformat) {
1547 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1553 oc->oformat = file_oformat;
1554 oc->interrupt_callback = int_cb;
1555 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1557 /* create streams for all unlabeled output pads */
1558 for (i = 0; i < nb_filtergraphs; i++) {
1559 FilterGraph *fg = filtergraphs[i];
1560 for (j = 0; j < fg->nb_outputs; j++) {
1561 OutputFilter *ofilter = fg->outputs[j];
1563 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1566 switch (ofilter->type) {
1567 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1568 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1569 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1571 init_output_filter(ofilter, o, oc);
1575 if (!o->nb_stream_maps) {
1576 /* pick the "best" stream of each type */
1577 #define NEW_STREAM(type, index)\
1579 ost = new_ ## type ## _stream(o, oc);\
1580 ost->source_index = index;\
1581 ost->sync_ist = input_streams[index];\
1582 input_streams[index]->discard = 0;\
1583 input_streams[index]->st->discard = AVDISCARD_NONE;\
1586 /* video: highest resolution */
1587 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1588 int area = 0, idx = -1;
1589 for (i = 0; i < nb_input_streams; i++) {
1590 ist = input_streams[i];
1591 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1592 ist->st->codecpar->width * ist->st->codecpar->height > area) {
1593 area = ist->st->codecpar->width * ist->st->codecpar->height;
1597 NEW_STREAM(video, idx);
1600 /* audio: most channels */
1601 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1602 int channels = 0, idx = -1;
1603 for (i = 0; i < nb_input_streams; i++) {
1604 ist = input_streams[i];
1605 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1606 ist->st->codecpar->channels > channels) {
1607 channels = ist->st->codecpar->channels;
1611 NEW_STREAM(audio, idx);
1614 /* subtitles: pick first */
1615 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1616 for (i = 0; i < nb_input_streams; i++)
1617 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1618 NEW_STREAM(subtitle, i);
1622 /* do something with data? */
1624 for (i = 0; i < o->nb_stream_maps; i++) {
1625 StreamMap *map = &o->stream_maps[i];
1630 if (map->linklabel) {
1632 OutputFilter *ofilter = NULL;
1635 for (j = 0; j < nb_filtergraphs; j++) {
1636 fg = filtergraphs[j];
1637 for (k = 0; k < fg->nb_outputs; k++) {
1638 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1639 if (out && !strcmp(out->name, map->linklabel)) {
1640 ofilter = fg->outputs[k];
1647 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1648 "in any defined filter graph.\n", map->linklabel);
1651 init_output_filter(ofilter, o, oc);
1653 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1654 switch (ist->st->codecpar->codec_type) {
1655 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1656 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1657 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1658 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1659 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1661 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1662 map->file_index, map->stream_index);
1666 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1667 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1668 map->sync_stream_index];
1670 ist->st->discard = AVDISCARD_NONE;
1675 /* handle attached files */
1676 for (i = 0; i < o->nb_attachments; i++) {
1678 uint8_t *attachment;
1682 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1683 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1687 if ((len = avio_size(pb)) <= 0) {
1688 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1692 if (!(attachment = av_malloc(len))) {
1693 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1697 avio_read(pb, attachment, len);
1699 ost = new_attachment_stream(o, oc);
1700 ost->stream_copy = 0;
1701 ost->source_index = -1;
1702 ost->attachment_filename = o->attachments[i];
1703 ost->st->codecpar->extradata = attachment;
1704 ost->st->codecpar->extradata_size = len;
1706 p = strrchr(o->attachments[i], '/');
1707 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1711 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1712 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1713 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1717 /* check if all codec options have been used */
1718 unused_opts = strip_specifiers(o->g->codec_opts);
1719 for (i = of->ost_index; i < nb_output_streams; i++) {
1721 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1722 AV_DICT_IGNORE_SUFFIX)))
1723 av_dict_set(&unused_opts, e->key, NULL, 0);
1727 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1728 const AVClass *class = avcodec_get_class();
1729 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1730 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1733 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1734 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1735 "output file #%d (%s) is not an encoding option.\n", e->key,
1736 option->help ? option->help : "", nb_output_files - 1,
1741 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1742 "output file #%d (%s) has not been used for any stream. The most "
1743 "likely reason is either wrong type (e.g. a video option with "
1744 "no video streams) or that it is a private option of some encoder "
1745 "which was not actually used for any stream.\n", e->key,
1746 option->help ? option->help : "", nb_output_files - 1, filename);
1748 av_dict_free(&unused_opts);
1750 /* set the decoding_needed flags and create simple filtergraphs */
1751 for (i = of->ost_index; i < nb_output_streams; i++) {
1752 OutputStream *ost = output_streams[i];
1754 if (ost->encoding_needed && ost->source_index >= 0) {
1755 InputStream *ist = input_streams[ost->source_index];
1756 ist->decoding_needed = 1;
1758 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1759 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1760 err = init_simple_filtergraph(ist, ost);
1762 av_log(NULL, AV_LOG_ERROR,
1763 "Error initializing a simple filtergraph between streams "
1764 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1765 nb_output_files - 1, ost->st->index);
1772 /* check filename in case of an image number is expected */
1773 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1774 if (!av_filename_number_test(oc->filename)) {
1775 print_error(oc->filename, AVERROR(EINVAL));
1780 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1781 /* test if it already exists to avoid losing precious files */
1782 assert_file_overwrite(filename);
1785 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1786 &oc->interrupt_callback,
1788 print_error(filename, err);
1793 if (o->mux_preload) {
1795 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1796 av_dict_set(&of->opts, "preload", buf, 0);
1798 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1799 oc->flags |= AVFMT_FLAG_NONBLOCK;
1802 for (i = 0; i < o->nb_metadata_map; i++) {
1804 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1806 if (in_file_index >= nb_input_files) {
1807 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1810 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1811 in_file_index >= 0 ?
1812 input_files[in_file_index]->ctx : NULL, o);
1816 if (o->chapters_input_file >= nb_input_files) {
1817 if (o->chapters_input_file == INT_MAX) {
1818 /* copy chapters from the first input file that has them*/
1819 o->chapters_input_file = -1;
1820 for (i = 0; i < nb_input_files; i++)
1821 if (input_files[i]->ctx->nb_chapters) {
1822 o->chapters_input_file = i;
1826 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1827 o->chapters_input_file);
1831 if (o->chapters_input_file >= 0)
1832 copy_chapters(input_files[o->chapters_input_file], of,
1833 !o->metadata_chapters_manual);
1835 /* copy global metadata by default */
1836 if (!o->metadata_global_manual && nb_input_files)
1837 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1838 AV_DICT_DONT_OVERWRITE);
1839 if (!o->metadata_streams_manual)
1840 for (i = of->ost_index; i < nb_output_streams; i++) {
1842 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1844 ist = input_streams[output_streams[i]->source_index];
1845 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1848 /* process manually set metadata */
1849 for (i = 0; i < o->nb_metadata; i++) {
1852 const char *stream_spec;
1853 int index = 0, j, ret;
1855 val = strchr(o->metadata[i].u.str, '=');
1857 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1858 o->metadata[i].u.str);
1863 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1865 for (j = 0; j < oc->nb_streams; j++) {
1866 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1867 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1878 if (index < 0 || index >= oc->nb_chapters) {
1879 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1882 m = &oc->chapters[index]->metadata;
1885 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1888 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1895 static int opt_target(void *optctx, const char *opt, const char *arg)
1897 OptionsContext *o = optctx;
1898 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1899 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1901 if (!strncmp(arg, "pal-", 4)) {
1904 } else if (!strncmp(arg, "ntsc-", 5)) {
1907 } else if (!strncmp(arg, "film-", 5)) {
1911 /* Try to determine PAL/NTSC by peeking in the input files */
1912 if (nb_input_files) {
1914 for (j = 0; j < nb_input_files; j++) {
1915 for (i = 0; i < input_files[j]->nb_streams; i++) {
1916 AVStream *st = input_files[j]->ctx->streams[i];
1917 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1919 fr = st->time_base.den * 1000 / st->time_base.num;
1923 } else if ((fr == 29970) || (fr == 23976)) {
1928 if (norm != UNKNOWN)
1932 if (norm != UNKNOWN)
1933 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1936 if (norm == UNKNOWN) {
1937 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1938 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1939 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1943 if (!strcmp(arg, "vcd")) {
1944 opt_video_codec(o, "c:v", "mpeg1video");
1945 opt_audio_codec(o, "c:a", "mp2");
1946 parse_option(o, "f", "vcd", options);
1948 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1949 parse_option(o, "r", frame_rates[norm], options);
1950 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1952 opt_default(NULL, "b", "1150000");
1953 opt_default(NULL, "maxrate", "1150000");
1954 opt_default(NULL, "minrate", "1150000");
1955 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1957 opt_default(NULL, "b:a", "224000");
1958 parse_option(o, "ar", "44100", options);
1959 parse_option(o, "ac", "2", options);
1961 opt_default(NULL, "packetsize", "2324");
1962 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1964 /* We have to offset the PTS, so that it is consistent with the SCR.
1965 SCR starts at 36000, but the first two packs contain only padding
1966 and the first pack from the other stream, respectively, may also have
1967 been written before.
1968 So the real data starts at SCR 36000+3*1200. */
1969 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1970 } else if (!strcmp(arg, "svcd")) {
1972 opt_video_codec(o, "c:v", "mpeg2video");
1973 opt_audio_codec(o, "c:a", "mp2");
1974 parse_option(o, "f", "svcd", options);
1976 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1977 parse_option(o, "r", frame_rates[norm], options);
1978 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1980 opt_default(NULL, "b", "2040000");
1981 opt_default(NULL, "maxrate", "2516000");
1982 opt_default(NULL, "minrate", "0"); // 1145000;
1983 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1984 opt_default(NULL, "scan_offset", "1");
1987 opt_default(NULL, "b:a", "224000");
1988 parse_option(o, "ar", "44100", options);
1990 opt_default(NULL, "packetsize", "2324");
1992 } else if (!strcmp(arg, "dvd")) {
1994 opt_video_codec(o, "c:v", "mpeg2video");
1995 opt_audio_codec(o, "c:a", "ac3");
1996 parse_option(o, "f", "dvd", options);
1998 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1999 parse_option(o, "r", frame_rates[norm], options);
2000 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2002 opt_default(NULL, "b", "6000000");
2003 opt_default(NULL, "maxrate", "9000000");
2004 opt_default(NULL, "minrate", "0"); // 1500000;
2005 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2007 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2008 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2010 opt_default(NULL, "b:a", "448000");
2011 parse_option(o, "ar", "48000", options);
2013 } else if (!strncmp(arg, "dv", 2)) {
2015 parse_option(o, "f", "dv", options);
2017 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2018 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2019 norm == PAL ? "yuv420p" : "yuv411p", options);
2020 parse_option(o, "r", frame_rates[norm], options);
2022 parse_option(o, "ar", "48000", options);
2023 parse_option(o, "ac", "2", options);
2026 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2027 return AVERROR(EINVAL);
2030 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
2031 av_dict_copy(&o->g->format_opts, format_opts, 0);
2036 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2038 av_free (vstats_filename);
2039 vstats_filename = av_strdup (arg);
2043 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2046 time_t today2 = time(NULL);
2047 struct tm *today = localtime(&today2);
2049 if (!today) { // maybe tomorrow
2050 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2054 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2056 return opt_vstats_file(NULL, opt, filename);
2059 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2061 OptionsContext *o = optctx;
2062 return parse_option(o, "frames:v", arg, options);
2065 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2067 OptionsContext *o = optctx;
2068 return parse_option(o, "frames:a", arg, options);
2071 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2073 OptionsContext *o = optctx;
2074 return parse_option(o, "frames:d", arg, options);
2077 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2079 OptionsContext *o = optctx;
2080 return parse_option(o, "tag:v", arg, options);
2083 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2085 OptionsContext *o = optctx;
2086 return parse_option(o, "tag:a", arg, options);
2089 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2091 OptionsContext *o = optctx;
2092 return parse_option(o, "tag:s", arg, options);
2095 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2097 OptionsContext *o = optctx;
2098 return parse_option(o, "filter:v", arg, options);
2101 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2103 OptionsContext *o = optctx;
2104 return parse_option(o, "filter:a", arg, options);
2107 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2109 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2110 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2111 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2113 if (video_sync_method == VSYNC_AUTO)
2114 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2118 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2120 OptionsContext *o = optctx;
2121 char layout_str[32];
2124 int ret, channels, ac_str_size;
2127 layout = av_get_channel_layout(arg);
2129 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2130 return AVERROR(EINVAL);
2132 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2133 ret = opt_default(NULL, opt, layout_str);
2137 /* set 'ac' option based on channel layout */
2138 channels = av_get_channel_layout_nb_channels(layout);
2139 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2140 stream_str = strchr(opt, ':');
2141 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2142 ac_str = av_mallocz(ac_str_size);
2144 return AVERROR(ENOMEM);
2145 av_strlcpy(ac_str, "ac", 3);
2147 av_strlcat(ac_str, stream_str, ac_str_size);
2148 ret = parse_option(o, ac_str, layout_str, options);
2154 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2156 OptionsContext *o = optctx;
2157 return parse_option(o, "q:a", arg, options);
2160 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2162 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2163 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2164 return AVERROR(ENOMEM);
2165 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2166 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2167 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2168 return AVERROR(ENOMEM);
2172 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2174 uint8_t *graph_desc = read_file(arg);
2176 return AVERROR(EINVAL);
2178 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2179 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2180 return AVERROR(ENOMEM);
2181 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2182 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2186 void show_help_default(const char *opt, const char *arg)
2188 /* per-file options have at least one of those set */
2189 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2190 int show_advanced = 0, show_avoptions = 0;
2193 if (!strcmp(opt, "long"))
2195 else if (!strcmp(opt, "full"))
2196 show_advanced = show_avoptions = 1;
2198 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2203 printf("Getting help:\n"
2204 " -h -- print basic options\n"
2205 " -h long -- print more options\n"
2206 " -h full -- print all options (including all format and codec specific options, very long)\n"
2207 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2208 " See man %s for detailed description of the options.\n"
2209 "\n", program_name);
2211 show_help_options(options, "Print help / information / capabilities:",
2214 show_help_options(options, "Global options (affect whole program "
2215 "instead of just one file:",
2216 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2218 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2219 per_file | OPT_EXIT, 0);
2221 show_help_options(options, "Per-file main options:", 0,
2222 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2223 OPT_EXIT, per_file);
2225 show_help_options(options, "Advanced per-file options:",
2226 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2228 show_help_options(options, "Video options:",
2229 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2231 show_help_options(options, "Advanced Video options:",
2232 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2234 show_help_options(options, "Audio options:",
2235 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2237 show_help_options(options, "Advanced Audio options:",
2238 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2239 show_help_options(options, "Subtitle options:",
2240 OPT_SUBTITLE, 0, 0);
2243 if (show_avoptions) {
2244 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2245 show_help_children(avcodec_get_class(), flags);
2246 show_help_children(avformat_get_class(), flags);
2247 show_help_children(sws_get_class(), flags);
2248 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2252 void show_usage(void)
2254 printf("Hyper fast Audio and Video encoder\n");
2255 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2264 static const OptionGroupDef groups[] = {
2265 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2266 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2269 static int open_files(OptionGroupList *l, const char *inout,
2270 int (*open_file)(OptionsContext*, const char*))
2274 for (i = 0; i < l->nb_groups; i++) {
2275 OptionGroup *g = &l->groups[i];
2281 ret = parse_optgroup(&o, g);
2283 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2284 "%s.\n", inout, g->arg);
2288 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2289 ret = open_file(&o, g->arg);
2292 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2296 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2302 int avconv_parse_options(int argc, char **argv)
2304 OptionParseContext octx;
2308 memset(&octx, 0, sizeof(octx));
2310 /* split the commandline into an internal representation */
2311 ret = split_commandline(&octx, argc, argv, options, groups,
2312 FF_ARRAY_ELEMS(groups));
2314 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2318 /* apply global options */
2319 ret = parse_optgroup(NULL, &octx.global_opts);
2321 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2325 /* open input files */
2326 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2328 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2332 /* create the complex filtergraphs */
2333 ret = init_complex_filters();
2335 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2339 /* open output files */
2340 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2342 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2346 /* configure the complex filtergraphs */
2347 ret = configure_complex_filters();
2349 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2354 uninit_parse_context(&octx);
2356 av_strerror(ret, error, sizeof(error));
2357 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2362 #define OFFSET(x) offsetof(OptionsContext, x)
2363 const OptionDef options[] = {
2365 #include "cmdutils_common_opts.h"
2366 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2367 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2368 "force format", "fmt" },
2369 { "y", OPT_BOOL, { &file_overwrite },
2370 "overwrite output files" },
2371 { "n", OPT_BOOL, { &file_skip },
2372 "never overwrite output files" },
2373 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2374 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2375 "codec name", "codec" },
2376 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2377 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2378 "codec name", "codec" },
2379 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2380 OPT_OUTPUT, { .off = OFFSET(presets) },
2381 "preset name", "preset" },
2382 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2383 OPT_OUTPUT, { .func_arg = opt_map },
2384 "set input stream mapping",
2385 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2386 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2387 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2388 "set metadata information of outfile from infile",
2389 "outfile[,metadata]:infile[,metadata]" },
2390 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2391 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2392 "set chapters mapping", "input_file_index" },
2393 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2394 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2395 "record or transcode \"duration\" seconds of audio/video",
2397 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2398 "set the limit file size in bytes", "limit_size" },
2399 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2400 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2401 "set the start time offset", "time_off" },
2402 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2403 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2404 "enable/disable accurate seeking with -ss" },
2405 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2406 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2407 "set the input ts offset", "time_off" },
2408 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2409 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2410 "set the input ts scale", "scale" },
2411 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2412 "add metadata", "string=string" },
2413 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2414 OPT_OUTPUT, { .func_arg = opt_data_frames },
2415 "set the number of data frames to record", "number" },
2416 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2417 "add timings for benchmarking" },
2418 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2419 "set max runtime in seconds", "limit" },
2420 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2421 "dump each input packet" },
2422 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2423 "when dumping packets, also dump the payload" },
2424 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2425 OPT_INPUT, { .off = OFFSET(rate_emu) },
2426 "read input at native frame rate", "" },
2427 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2428 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2429 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2430 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2431 "video sync method", "" },
2432 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2433 "audio sync method", "" },
2434 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2435 "audio drift threshold", "threshold" },
2436 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2437 "copy timestamps" },
2438 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2439 "copy input stream time base when stream copying" },
2440 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2441 OPT_OUTPUT, { .off = OFFSET(shortest) },
2442 "finish encoding within shortest input" },
2443 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2444 "timestamp discontinuity delta threshold", "threshold" },
2445 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2446 "exit on error", "error" },
2447 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2448 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2449 "copy initial non-keyframes" },
2450 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2451 "set the number of frames to record", "number" },
2452 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2453 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2454 "force codec tag/fourcc", "fourcc/tag" },
2455 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2456 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2457 "use fixed quality scale (VBR)", "q" },
2458 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2459 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2460 "use fixed quality scale (VBR)", "q" },
2461 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2462 "set stream filterchain", "filter_list" },
2463 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2464 "read stream filtergraph description from a file", "filename" },
2465 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2466 "create a complex filtergraph", "graph_description" },
2467 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2468 "read complex filtergraph description from a file", "filename" },
2469 { "stats", OPT_BOOL, { &print_stats },
2470 "print progress report during encoding", },
2471 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2472 OPT_OUTPUT, { .func_arg = opt_attach },
2473 "add an attachment to the output file", "filename" },
2474 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2475 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2476 "extract an attachment into a file", "filename" },
2477 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2478 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2481 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2482 "set the number of video frames to record", "number" },
2483 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2484 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2485 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2486 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2487 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2488 "set frame size (WxH or abbreviation)", "size" },
2489 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2490 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2491 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2492 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2493 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2494 "set pixel format", "format" },
2495 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2497 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2498 "discard threshold", "n" },
2499 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2500 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2501 "rate control override for specific intervals", "override" },
2502 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2503 OPT_OUTPUT, { .func_arg = opt_video_codec },
2504 "force video codec ('copy' to copy stream)", "codec" },
2505 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2506 "select the pass number (1 or 2)", "n" },
2507 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2508 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2509 "select two pass log file name prefix", "prefix" },
2510 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2511 "dump video coding statistics to file" },
2512 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2513 "dump video coding statistics to file", "file" },
2514 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2515 "video filters", "filter list" },
2516 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2517 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2518 "specify intra matrix coeffs", "matrix" },
2519 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2520 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2521 "specify inter matrix coeffs", "matrix" },
2522 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2523 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2524 "top=1/bottom=0/auto=-1 field first", "" },
2525 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2526 "intra_dc_precision", "precision" },
2527 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2528 OPT_OUTPUT, { .func_arg = opt_video_tag },
2529 "force video tag/fourcc", "fourcc/tag" },
2530 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2531 "show QP histogram" },
2532 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2533 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2534 "force the selected framerate, disable the best supported framerate selection" },
2535 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2536 OPT_OUTPUT, { .func_arg = opt_streamid },
2537 "set the value of an outfile streamid", "streamIndex:value" },
2538 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2539 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2540 "force key frames at specified timestamps", "timestamps" },
2541 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2542 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2543 "use HW accelerated decoding", "hwaccel name" },
2544 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2545 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2546 "select a device for HW acceleration", "devicename" },
2547 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2548 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
2549 "select output format used with HW accelerated decoding", "format" },
2551 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2552 "show available HW acceleration methods" },
2553 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2554 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2555 "automatically insert correct rotate filters" },
2556 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
2557 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2560 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2561 "set the number of audio frames to record", "number" },
2562 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2563 "set audio quality (codec-specific)", "quality", },
2564 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2565 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2566 "set audio sampling rate (in Hz)", "rate" },
2567 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2568 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2569 "set number of audio channels", "channels" },
2570 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2572 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2573 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2574 "force audio codec ('copy' to copy stream)", "codec" },
2575 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2576 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2577 "force audio tag/fourcc", "fourcc/tag" },
2578 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2579 "change audio volume (256=normal)" , "volume" },
2580 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2581 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2582 "set sample format", "format" },
2583 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2584 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2585 "set channel layout", "layout" },
2586 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2587 "audio filters", "filter list" },
2589 /* subtitle options */
2590 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2591 "disable subtitle" },
2592 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2593 "force subtitle codec ('copy' to copy stream)", "codec" },
2594 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2595 , "force subtitle tag/fourcc", "fourcc/tag" },
2598 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2601 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2602 "set the maximum demux-decode delay", "seconds" },
2603 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2604 "set the initial demux-decode delay", "seconds" },
2606 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2607 "A comma-separated list of bitstream filters", "bitstream_filters" },
2609 /* data codec support */
2610 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2611 "force data codec ('copy' to copy stream)", "codec" },
2614 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2615 "set VAAPI hardware device (DRM path or X11 display name)", "device" },