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 void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
924 char *codec_name = NULL;
926 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
928 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
929 NULL, ost->st->codecpar->codec_type);
930 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
931 } else if (!strcmp(codec_name, "copy"))
932 ost->stream_copy = 1;
934 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
935 ost->st->codecpar->codec_id = ost->enc->id;
939 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
942 AVStream *st = avformat_new_stream(oc, NULL);
943 int idx = oc->nb_streams - 1, ret = 0;
944 char *bsf = NULL, *next, *codec_tag = NULL;
948 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
952 if (oc->nb_streams - 1 < o->nb_streamid_map)
953 st->id = o->streamid_map[oc->nb_streams - 1];
955 GROW_ARRAY(output_streams, nb_output_streams);
956 if (!(ost = av_mallocz(sizeof(*ost))))
958 output_streams[nb_output_streams - 1] = ost;
960 ost->file_index = nb_output_files - 1;
963 st->codecpar->codec_type = type;
964 choose_encoder(o, oc, ost);
966 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
968 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
971 ost->enc_ctx->codec_type = type;
974 AVIOContext *s = NULL;
975 char *buf = NULL, *arg = NULL, *preset = NULL;
977 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
979 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
980 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
983 if (!buf[0] || buf[0] == '#') {
987 if (!(arg = strchr(buf, '='))) {
988 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
992 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
994 } while (!s->eof_reached);
998 av_log(NULL, AV_LOG_FATAL,
999 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1000 preset, ost->file_index, ost->index);
1004 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1007 ost->max_frames = INT64_MAX;
1008 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1010 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1012 const AVBitStreamFilter *filter;
1014 if (next = strchr(bsf, ','))
1017 filter = av_bsf_get_by_name(bsf);
1019 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1023 ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
1024 ost->nb_bitstream_filters + 1,
1025 sizeof(*ost->bitstream_filters));
1026 if (!ost->bitstream_filters)
1029 ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
1034 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1036 uint32_t tag = strtol(codec_tag, &next, 0);
1038 tag = AV_RL32(codec_tag);
1039 ost->enc_ctx->codec_tag = tag;
1042 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1044 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1045 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1048 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1049 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1051 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1053 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1055 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1056 ost->last_mux_dts = AV_NOPTS_VALUE;
1061 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1064 const char *p = str;
1071 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1078 /* read file contents into a string */
1079 static uint8_t *read_file(const char *filename)
1081 AVIOContext *pb = NULL;
1082 AVIOContext *dyn_buf = NULL;
1083 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1084 uint8_t buf[1024], *str;
1087 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1091 ret = avio_open_dyn_buf(&dyn_buf);
1096 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1097 avio_write(dyn_buf, buf, ret);
1098 avio_w8(dyn_buf, 0);
1101 ret = avio_close_dyn_buf(dyn_buf, &str);
1107 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1110 AVStream *st = ost->st;
1111 char *filter = NULL, *filter_script = NULL;
1113 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1114 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1116 if (filter_script && filter) {
1117 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1118 "output stream #%d:%d.\n", nb_output_files, st->index);
1123 return read_file(filter_script);
1125 return av_strdup(filter);
1127 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1131 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1135 AVCodecContext *video_enc;
1136 char *frame_aspect_ratio = NULL;
1138 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1140 video_enc = ost->enc_ctx;
1142 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1143 if (frame_aspect_ratio)
1144 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1146 if (!ost->stream_copy) {
1147 const char *p = NULL;
1148 char *frame_rate = NULL, *frame_size = NULL;
1149 char *frame_pix_fmt = NULL;
1150 char *intra_matrix = NULL, *inter_matrix = NULL;
1154 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1155 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1156 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1160 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1161 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1162 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1166 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1167 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1168 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1171 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1173 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1175 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1176 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1179 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1181 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1183 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1184 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1187 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1190 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1191 for (i = 0; p; i++) {
1193 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1195 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1198 video_enc->rc_override =
1199 av_realloc(video_enc->rc_override,
1200 sizeof(RcOverride) * (i + 1));
1201 if (!video_enc->rc_override) {
1202 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1205 video_enc->rc_override[i].start_frame = start;
1206 video_enc->rc_override[i].end_frame = end;
1208 video_enc->rc_override[i].qscale = q;
1209 video_enc->rc_override[i].quality_factor = 1.0;
1212 video_enc->rc_override[i].qscale = 0;
1213 video_enc->rc_override[i].quality_factor = -q/100.0;
1218 video_enc->rc_override_count = i;
1219 video_enc->intra_dc_precision = intra_dc_precision - 8;
1222 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1225 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1227 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1231 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1232 if (ost->logfile_prefix &&
1233 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1237 char logfilename[1024];
1240 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1241 ost->logfile_prefix ? ost->logfile_prefix :
1242 DEFAULT_PASS_LOGFILENAME_PREFIX,
1244 if (!strcmp(ost->enc->name, "libx264")) {
1245 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1247 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1248 f = fopen(logfilename, "wb");
1250 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1251 logfilename, strerror(errno));
1256 char *logbuffer = read_file(logfilename);
1259 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1263 video_enc->stats_in = logbuffer;
1268 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1269 if (ost->forced_keyframes)
1270 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1272 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1274 ost->top_field_first = -1;
1275 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1278 ost->avfilter = get_ost_filters(o, oc, ost);
1282 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1288 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1292 AVCodecContext *audio_enc;
1294 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1297 audio_enc = ost->enc_ctx;
1298 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1300 if (!ost->stream_copy) {
1301 char *sample_fmt = NULL;
1303 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1305 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1307 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1308 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1312 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1314 ost->avfilter = get_ost_filters(o, oc, ost);
1322 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1326 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1327 if (!ost->stream_copy) {
1328 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1335 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1337 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1338 ost->stream_copy = 1;
1343 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1346 AVCodecContext *subtitle_enc;
1348 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1349 subtitle_enc = ost->enc_ctx;
1351 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1356 /* arg format is "output-stream-index:streamid-value". */
1357 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1359 OptionsContext *o = optctx;
1364 av_strlcpy(idx_str, arg, sizeof(idx_str));
1365 p = strchr(idx_str, ':');
1367 av_log(NULL, AV_LOG_FATAL,
1368 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1373 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1374 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1375 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1379 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1381 AVFormatContext *is = ifile->ctx;
1382 AVFormatContext *os = ofile->ctx;
1386 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1388 return AVERROR(ENOMEM);
1391 for (i = 0; i < is->nb_chapters; i++) {
1392 AVChapter *in_ch = is->chapters[i], *out_ch;
1393 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1394 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1395 AV_TIME_BASE_Q, in_ch->time_base);
1396 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1397 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1400 if (in_ch->end < ts_off)
1402 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1405 out_ch = av_mallocz(sizeof(AVChapter));
1407 return AVERROR(ENOMEM);
1409 out_ch->id = in_ch->id;
1410 out_ch->time_base = in_ch->time_base;
1411 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1412 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1415 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1417 os->chapters[os->nb_chapters++] = out_ch;
1422 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1423 AVFormatContext *oc)
1427 switch (ofilter->type) {
1428 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1429 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1431 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1436 ost->source_index = -1;
1437 ost->filter = ofilter;
1441 if (ost->stream_copy) {
1442 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1443 "which is fed from a complex filtergraph. Filtering and streamcopy "
1444 "cannot be used together.\n", ost->file_index, ost->index);
1448 avfilter_inout_free(&ofilter->out_tmp);
1451 static int init_complex_filters(void)
1455 for (i = 0; i < nb_filtergraphs; i++) {
1456 ret = init_complex_filtergraph(filtergraphs[i]);
1463 static int configure_complex_filters(void)
1467 for (i = 0; i < nb_filtergraphs; i++)
1468 if (!filtergraphs[i]->graph &&
1469 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1474 static int open_output_file(OptionsContext *o, const char *filename)
1476 AVFormatContext *oc;
1478 AVOutputFormat *file_oformat;
1482 AVDictionary *unused_opts = NULL;
1483 AVDictionaryEntry *e = NULL;
1485 GROW_ARRAY(output_files, nb_output_files);
1486 of = av_mallocz(sizeof(*of));
1489 output_files[nb_output_files - 1] = of;
1491 of->ost_index = nb_output_streams;
1492 of->recording_time = o->recording_time;
1493 of->start_time = o->start_time;
1494 of->limit_filesize = o->limit_filesize;
1495 of->shortest = o->shortest;
1496 av_dict_copy(&of->opts, o->g->format_opts, 0);
1498 if (!strcmp(filename, "-"))
1501 oc = avformat_alloc_context();
1503 print_error(filename, AVERROR(ENOMEM));
1507 if (o->recording_time != INT64_MAX)
1508 oc->duration = o->recording_time;
1511 file_oformat = av_guess_format(o->format, NULL, NULL);
1512 if (!file_oformat) {
1513 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1517 file_oformat = av_guess_format(NULL, filename, NULL);
1518 if (!file_oformat) {
1519 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1525 oc->oformat = file_oformat;
1526 oc->interrupt_callback = int_cb;
1527 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1529 /* create streams for all unlabeled output pads */
1530 for (i = 0; i < nb_filtergraphs; i++) {
1531 FilterGraph *fg = filtergraphs[i];
1532 for (j = 0; j < fg->nb_outputs; j++) {
1533 OutputFilter *ofilter = fg->outputs[j];
1535 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1538 switch (ofilter->type) {
1539 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1540 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1541 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1543 init_output_filter(ofilter, o, oc);
1547 if (!o->nb_stream_maps) {
1548 /* pick the "best" stream of each type */
1549 #define NEW_STREAM(type, index)\
1551 ost = new_ ## type ## _stream(o, oc);\
1552 ost->source_index = index;\
1553 ost->sync_ist = input_streams[index];\
1554 input_streams[index]->discard = 0;\
1555 input_streams[index]->st->discard = AVDISCARD_NONE;\
1558 /* video: highest resolution */
1559 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1560 int area = 0, idx = -1;
1561 for (i = 0; i < nb_input_streams; i++) {
1562 ist = input_streams[i];
1563 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1564 ist->st->codecpar->width * ist->st->codecpar->height > area) {
1565 area = ist->st->codecpar->width * ist->st->codecpar->height;
1569 NEW_STREAM(video, idx);
1572 /* audio: most channels */
1573 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1574 int channels = 0, idx = -1;
1575 for (i = 0; i < nb_input_streams; i++) {
1576 ist = input_streams[i];
1577 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1578 ist->st->codecpar->channels > channels) {
1579 channels = ist->st->codecpar->channels;
1583 NEW_STREAM(audio, idx);
1586 /* subtitles: pick first */
1587 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1588 for (i = 0; i < nb_input_streams; i++)
1589 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1590 NEW_STREAM(subtitle, i);
1594 /* do something with data? */
1596 for (i = 0; i < o->nb_stream_maps; i++) {
1597 StreamMap *map = &o->stream_maps[i];
1602 if (map->linklabel) {
1604 OutputFilter *ofilter = NULL;
1607 for (j = 0; j < nb_filtergraphs; j++) {
1608 fg = filtergraphs[j];
1609 for (k = 0; k < fg->nb_outputs; k++) {
1610 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1611 if (out && !strcmp(out->name, map->linklabel)) {
1612 ofilter = fg->outputs[k];
1619 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1620 "in any defined filter graph.\n", map->linklabel);
1623 init_output_filter(ofilter, o, oc);
1625 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1626 switch (ist->st->codecpar->codec_type) {
1627 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1628 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1629 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1630 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1631 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1633 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1634 map->file_index, map->stream_index);
1638 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1639 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1640 map->sync_stream_index];
1642 ist->st->discard = AVDISCARD_NONE;
1647 /* handle attached files */
1648 for (i = 0; i < o->nb_attachments; i++) {
1650 uint8_t *attachment;
1654 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1655 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1659 if ((len = avio_size(pb)) <= 0) {
1660 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1664 if (!(attachment = av_malloc(len))) {
1665 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1669 avio_read(pb, attachment, len);
1671 ost = new_attachment_stream(o, oc);
1672 ost->stream_copy = 0;
1673 ost->source_index = -1;
1674 ost->attachment_filename = o->attachments[i];
1675 ost->st->codecpar->extradata = attachment;
1676 ost->st->codecpar->extradata_size = len;
1678 p = strrchr(o->attachments[i], '/');
1679 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1683 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1684 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1685 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1689 /* check if all codec options have been used */
1690 unused_opts = strip_specifiers(o->g->codec_opts);
1691 for (i = of->ost_index; i < nb_output_streams; i++) {
1693 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1694 AV_DICT_IGNORE_SUFFIX)))
1695 av_dict_set(&unused_opts, e->key, NULL, 0);
1699 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1700 const AVClass *class = avcodec_get_class();
1701 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1702 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1705 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1706 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1707 "output file #%d (%s) is not an encoding option.\n", e->key,
1708 option->help ? option->help : "", nb_output_files - 1,
1713 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1714 "output file #%d (%s) has not been used for any stream. The most "
1715 "likely reason is either wrong type (e.g. a video option with "
1716 "no video streams) or that it is a private option of some encoder "
1717 "which was not actually used for any stream.\n", e->key,
1718 option->help ? option->help : "", nb_output_files - 1, filename);
1720 av_dict_free(&unused_opts);
1722 /* set the encoding/decoding_needed flags */
1723 for (i = of->ost_index; i < nb_output_streams; i++) {
1724 OutputStream *ost = output_streams[i];
1726 ost->encoding_needed = !ost->stream_copy;
1727 if (ost->encoding_needed && ost->source_index >= 0) {
1728 InputStream *ist = input_streams[ost->source_index];
1729 ist->decoding_needed = 1;
1733 /* check filename in case of an image number is expected */
1734 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1735 if (!av_filename_number_test(oc->filename)) {
1736 print_error(oc->filename, AVERROR(EINVAL));
1741 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1742 /* test if it already exists to avoid losing precious files */
1743 assert_file_overwrite(filename);
1746 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1747 &oc->interrupt_callback,
1749 print_error(filename, err);
1754 if (o->mux_preload) {
1756 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1757 av_dict_set(&of->opts, "preload", buf, 0);
1759 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1760 oc->flags |= AVFMT_FLAG_NONBLOCK;
1763 for (i = 0; i < o->nb_metadata_map; i++) {
1765 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1767 if (in_file_index >= nb_input_files) {
1768 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1771 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1772 in_file_index >= 0 ?
1773 input_files[in_file_index]->ctx : NULL, o);
1777 if (o->chapters_input_file >= nb_input_files) {
1778 if (o->chapters_input_file == INT_MAX) {
1779 /* copy chapters from the first input file that has them*/
1780 o->chapters_input_file = -1;
1781 for (i = 0; i < nb_input_files; i++)
1782 if (input_files[i]->ctx->nb_chapters) {
1783 o->chapters_input_file = i;
1787 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1788 o->chapters_input_file);
1792 if (o->chapters_input_file >= 0)
1793 copy_chapters(input_files[o->chapters_input_file], of,
1794 !o->metadata_chapters_manual);
1796 /* copy global metadata by default */
1797 if (!o->metadata_global_manual && nb_input_files)
1798 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1799 AV_DICT_DONT_OVERWRITE);
1800 if (!o->metadata_streams_manual)
1801 for (i = of->ost_index; i < nb_output_streams; i++) {
1803 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1805 ist = input_streams[output_streams[i]->source_index];
1806 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1809 /* process manually set metadata */
1810 for (i = 0; i < o->nb_metadata; i++) {
1813 const char *stream_spec;
1814 int index = 0, j, ret;
1816 val = strchr(o->metadata[i].u.str, '=');
1818 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1819 o->metadata[i].u.str);
1824 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1826 for (j = 0; j < oc->nb_streams; j++) {
1827 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1828 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1839 if (index < 0 || index >= oc->nb_chapters) {
1840 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1843 m = &oc->chapters[index]->metadata;
1846 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1849 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1856 static int opt_target(void *optctx, const char *opt, const char *arg)
1858 OptionsContext *o = optctx;
1859 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1860 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1862 if (!strncmp(arg, "pal-", 4)) {
1865 } else if (!strncmp(arg, "ntsc-", 5)) {
1868 } else if (!strncmp(arg, "film-", 5)) {
1872 /* Try to determine PAL/NTSC by peeking in the input files */
1873 if (nb_input_files) {
1875 for (j = 0; j < nb_input_files; j++) {
1876 for (i = 0; i < input_files[j]->nb_streams; i++) {
1877 AVStream *st = input_files[j]->ctx->streams[i];
1878 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1880 fr = st->time_base.den * 1000 / st->time_base.num;
1884 } else if ((fr == 29970) || (fr == 23976)) {
1889 if (norm != UNKNOWN)
1893 if (norm != UNKNOWN)
1894 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1897 if (norm == UNKNOWN) {
1898 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1899 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1900 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1904 if (!strcmp(arg, "vcd")) {
1905 opt_video_codec(o, "c:v", "mpeg1video");
1906 opt_audio_codec(o, "c:a", "mp2");
1907 parse_option(o, "f", "vcd", options);
1909 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1910 parse_option(o, "r", frame_rates[norm], options);
1911 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1913 opt_default(NULL, "b", "1150000");
1914 opt_default(NULL, "maxrate", "1150000");
1915 opt_default(NULL, "minrate", "1150000");
1916 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1918 opt_default(NULL, "b:a", "224000");
1919 parse_option(o, "ar", "44100", options);
1920 parse_option(o, "ac", "2", options);
1922 opt_default(NULL, "packetsize", "2324");
1923 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1925 /* We have to offset the PTS, so that it is consistent with the SCR.
1926 SCR starts at 36000, but the first two packs contain only padding
1927 and the first pack from the other stream, respectively, may also have
1928 been written before.
1929 So the real data starts at SCR 36000+3*1200. */
1930 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1931 } else if (!strcmp(arg, "svcd")) {
1933 opt_video_codec(o, "c:v", "mpeg2video");
1934 opt_audio_codec(o, "c:a", "mp2");
1935 parse_option(o, "f", "svcd", options);
1937 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1938 parse_option(o, "r", frame_rates[norm], options);
1939 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1941 opt_default(NULL, "b", "2040000");
1942 opt_default(NULL, "maxrate", "2516000");
1943 opt_default(NULL, "minrate", "0"); // 1145000;
1944 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1945 opt_default(NULL, "scan_offset", "1");
1948 opt_default(NULL, "b:a", "224000");
1949 parse_option(o, "ar", "44100", options);
1951 opt_default(NULL, "packetsize", "2324");
1953 } else if (!strcmp(arg, "dvd")) {
1955 opt_video_codec(o, "c:v", "mpeg2video");
1956 opt_audio_codec(o, "c:a", "ac3");
1957 parse_option(o, "f", "dvd", options);
1959 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1960 parse_option(o, "r", frame_rates[norm], options);
1961 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1963 opt_default(NULL, "b", "6000000");
1964 opt_default(NULL, "maxrate", "9000000");
1965 opt_default(NULL, "minrate", "0"); // 1500000;
1966 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1968 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1969 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1971 opt_default(NULL, "b:a", "448000");
1972 parse_option(o, "ar", "48000", options);
1974 } else if (!strncmp(arg, "dv", 2)) {
1976 parse_option(o, "f", "dv", options);
1978 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1979 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1980 norm == PAL ? "yuv420p" : "yuv411p", options);
1981 parse_option(o, "r", frame_rates[norm], options);
1983 parse_option(o, "ar", "48000", options);
1984 parse_option(o, "ac", "2", options);
1987 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1988 return AVERROR(EINVAL);
1991 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1992 av_dict_copy(&o->g->format_opts, format_opts, 0);
1997 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1999 av_free (vstats_filename);
2000 vstats_filename = av_strdup (arg);
2004 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2007 time_t today2 = time(NULL);
2008 struct tm *today = localtime(&today2);
2010 if (!today) { // maybe tomorrow
2011 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2015 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2017 return opt_vstats_file(NULL, opt, filename);
2020 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2022 OptionsContext *o = optctx;
2023 return parse_option(o, "frames:v", arg, options);
2026 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2028 OptionsContext *o = optctx;
2029 return parse_option(o, "frames:a", arg, options);
2032 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2034 OptionsContext *o = optctx;
2035 return parse_option(o, "frames:d", arg, options);
2038 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2040 OptionsContext *o = optctx;
2041 return parse_option(o, "tag:v", arg, options);
2044 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2046 OptionsContext *o = optctx;
2047 return parse_option(o, "tag:a", arg, options);
2050 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2052 OptionsContext *o = optctx;
2053 return parse_option(o, "tag:s", arg, options);
2056 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2058 OptionsContext *o = optctx;
2059 return parse_option(o, "filter:v", arg, options);
2062 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2064 OptionsContext *o = optctx;
2065 return parse_option(o, "filter:a", arg, options);
2068 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2070 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2071 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2072 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2074 if (video_sync_method == VSYNC_AUTO)
2075 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2079 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2081 OptionsContext *o = optctx;
2082 char layout_str[32];
2085 int ret, channels, ac_str_size;
2088 layout = av_get_channel_layout(arg);
2090 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2091 return AVERROR(EINVAL);
2093 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2094 ret = opt_default(NULL, opt, layout_str);
2098 /* set 'ac' option based on channel layout */
2099 channels = av_get_channel_layout_nb_channels(layout);
2100 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2101 stream_str = strchr(opt, ':');
2102 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2103 ac_str = av_mallocz(ac_str_size);
2105 return AVERROR(ENOMEM);
2106 av_strlcpy(ac_str, "ac", 3);
2108 av_strlcat(ac_str, stream_str, ac_str_size);
2109 ret = parse_option(o, ac_str, layout_str, options);
2115 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2117 OptionsContext *o = optctx;
2118 return parse_option(o, "q:a", arg, options);
2121 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2123 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2124 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2125 return AVERROR(ENOMEM);
2126 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2127 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2128 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2129 return AVERROR(ENOMEM);
2133 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2135 uint8_t *graph_desc = read_file(arg);
2137 return AVERROR(EINVAL);
2139 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2140 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2141 return AVERROR(ENOMEM);
2142 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2143 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2147 void show_help_default(const char *opt, const char *arg)
2149 /* per-file options have at least one of those set */
2150 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2151 int show_advanced = 0, show_avoptions = 0;
2154 if (!strcmp(opt, "long"))
2156 else if (!strcmp(opt, "full"))
2157 show_advanced = show_avoptions = 1;
2159 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2164 printf("Getting help:\n"
2165 " -h -- print basic options\n"
2166 " -h long -- print more options\n"
2167 " -h full -- print all options (including all format and codec specific options, very long)\n"
2168 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2169 " See man %s for detailed description of the options.\n"
2170 "\n", program_name);
2172 show_help_options(options, "Print help / information / capabilities:",
2175 show_help_options(options, "Global options (affect whole program "
2176 "instead of just one file:",
2177 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2179 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2180 per_file | OPT_EXIT, 0);
2182 show_help_options(options, "Per-file main options:", 0,
2183 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2184 OPT_EXIT, per_file);
2186 show_help_options(options, "Advanced per-file options:",
2187 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2189 show_help_options(options, "Video options:",
2190 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2192 show_help_options(options, "Advanced Video options:",
2193 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2195 show_help_options(options, "Audio options:",
2196 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2198 show_help_options(options, "Advanced Audio options:",
2199 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2200 show_help_options(options, "Subtitle options:",
2201 OPT_SUBTITLE, 0, 0);
2204 if (show_avoptions) {
2205 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2206 show_help_children(avcodec_get_class(), flags);
2207 show_help_children(avformat_get_class(), flags);
2208 show_help_children(sws_get_class(), flags);
2209 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2213 void show_usage(void)
2215 printf("Hyper fast Audio and Video encoder\n");
2216 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2225 static const OptionGroupDef groups[] = {
2226 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2227 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2230 static int open_files(OptionGroupList *l, const char *inout,
2231 int (*open_file)(OptionsContext*, const char*))
2235 for (i = 0; i < l->nb_groups; i++) {
2236 OptionGroup *g = &l->groups[i];
2242 ret = parse_optgroup(&o, g);
2244 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2245 "%s.\n", inout, g->arg);
2249 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2250 ret = open_file(&o, g->arg);
2253 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2257 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2263 int avconv_parse_options(int argc, char **argv)
2265 OptionParseContext octx;
2269 memset(&octx, 0, sizeof(octx));
2271 /* split the commandline into an internal representation */
2272 ret = split_commandline(&octx, argc, argv, options, groups,
2273 FF_ARRAY_ELEMS(groups));
2275 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2279 /* apply global options */
2280 ret = parse_optgroup(NULL, &octx.global_opts);
2282 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2286 /* open input files */
2287 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2289 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2293 /* create the complex filtergraphs */
2294 ret = init_complex_filters();
2296 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2300 /* open output files */
2301 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2303 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2307 /* configure the complex filtergraphs */
2308 ret = configure_complex_filters();
2310 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2315 uninit_parse_context(&octx);
2317 av_strerror(ret, error, sizeof(error));
2318 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2323 #define OFFSET(x) offsetof(OptionsContext, x)
2324 const OptionDef options[] = {
2326 #include "cmdutils_common_opts.h"
2327 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2328 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2329 "force format", "fmt" },
2330 { "y", OPT_BOOL, { &file_overwrite },
2331 "overwrite output files" },
2332 { "n", OPT_BOOL, { &file_skip },
2333 "never overwrite output files" },
2334 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2335 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2336 "codec name", "codec" },
2337 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2338 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2339 "codec name", "codec" },
2340 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2341 OPT_OUTPUT, { .off = OFFSET(presets) },
2342 "preset name", "preset" },
2343 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2344 OPT_OUTPUT, { .func_arg = opt_map },
2345 "set input stream mapping",
2346 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2347 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2348 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2349 "set metadata information of outfile from infile",
2350 "outfile[,metadata]:infile[,metadata]" },
2351 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2352 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2353 "set chapters mapping", "input_file_index" },
2354 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2355 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2356 "record or transcode \"duration\" seconds of audio/video",
2358 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2359 "set the limit file size in bytes", "limit_size" },
2360 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2361 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2362 "set the start time offset", "time_off" },
2363 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2364 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2365 "enable/disable accurate seeking with -ss" },
2366 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2367 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2368 "set the input ts offset", "time_off" },
2369 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2370 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2371 "set the input ts scale", "scale" },
2372 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2373 "add metadata", "string=string" },
2374 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2375 OPT_OUTPUT, { .func_arg = opt_data_frames },
2376 "set the number of data frames to record", "number" },
2377 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2378 "add timings for benchmarking" },
2379 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2380 "set max runtime in seconds", "limit" },
2381 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2382 "dump each input packet" },
2383 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2384 "when dumping packets, also dump the payload" },
2385 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2386 OPT_INPUT, { .off = OFFSET(rate_emu) },
2387 "read input at native frame rate", "" },
2388 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2389 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2390 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2391 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2392 "video sync method", "" },
2393 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2394 "audio sync method", "" },
2395 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2396 "audio drift threshold", "threshold" },
2397 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2398 "copy timestamps" },
2399 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2400 "copy input stream time base when stream copying" },
2401 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2402 OPT_OUTPUT, { .off = OFFSET(shortest) },
2403 "finish encoding within shortest input" },
2404 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2405 "timestamp discontinuity delta threshold", "threshold" },
2406 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2407 "exit on error", "error" },
2408 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2409 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2410 "copy initial non-keyframes" },
2411 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2412 "set the number of frames to record", "number" },
2413 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2414 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2415 "force codec tag/fourcc", "fourcc/tag" },
2416 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2417 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2418 "use fixed quality scale (VBR)", "q" },
2419 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2420 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2421 "use fixed quality scale (VBR)", "q" },
2422 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2423 "set stream filterchain", "filter_list" },
2424 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2425 "read stream filtergraph description from a file", "filename" },
2426 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2427 "create a complex filtergraph", "graph_description" },
2428 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2429 "read complex filtergraph description from a file", "filename" },
2430 { "stats", OPT_BOOL, { &print_stats },
2431 "print progress report during encoding", },
2432 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2433 OPT_OUTPUT, { .func_arg = opt_attach },
2434 "add an attachment to the output file", "filename" },
2435 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2436 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2437 "extract an attachment into a file", "filename" },
2438 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2439 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2442 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2443 "set the number of video frames to record", "number" },
2444 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2445 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2446 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2447 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2448 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2449 "set frame size (WxH or abbreviation)", "size" },
2450 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2451 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2452 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2453 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2454 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2455 "set pixel format", "format" },
2456 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2458 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2459 "discard threshold", "n" },
2460 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2461 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2462 "rate control override for specific intervals", "override" },
2463 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2464 OPT_OUTPUT, { .func_arg = opt_video_codec },
2465 "force video codec ('copy' to copy stream)", "codec" },
2466 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2467 "select the pass number (1 or 2)", "n" },
2468 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2469 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2470 "select two pass log file name prefix", "prefix" },
2471 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2472 "dump video coding statistics to file" },
2473 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2474 "dump video coding statistics to file", "file" },
2475 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2476 "video filters", "filter list" },
2477 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2478 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2479 "specify intra matrix coeffs", "matrix" },
2480 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2481 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2482 "specify inter matrix coeffs", "matrix" },
2483 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2484 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2485 "top=1/bottom=0/auto=-1 field first", "" },
2486 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2487 "intra_dc_precision", "precision" },
2488 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2489 OPT_OUTPUT, { .func_arg = opt_video_tag },
2490 "force video tag/fourcc", "fourcc/tag" },
2491 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2492 "show QP histogram" },
2493 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2494 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2495 "force the selected framerate, disable the best supported framerate selection" },
2496 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2497 OPT_OUTPUT, { .func_arg = opt_streamid },
2498 "set the value of an outfile streamid", "streamIndex:value" },
2499 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2500 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2501 "force key frames at specified timestamps", "timestamps" },
2502 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2503 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2504 "use HW accelerated decoding", "hwaccel name" },
2505 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2506 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2507 "select a device for HW acceleration", "devicename" },
2508 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2509 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
2510 "select output format used with HW accelerated decoding", "format" },
2512 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2513 "show available HW acceleration methods" },
2514 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2515 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2516 "automatically insert correct rotate filters" },
2517 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
2518 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2521 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2522 "set the number of audio frames to record", "number" },
2523 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2524 "set audio quality (codec-specific)", "quality", },
2525 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2526 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2527 "set audio sampling rate (in Hz)", "rate" },
2528 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2529 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2530 "set number of audio channels", "channels" },
2531 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2533 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2534 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2535 "force audio codec ('copy' to copy stream)", "codec" },
2536 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2537 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2538 "force audio tag/fourcc", "fourcc/tag" },
2539 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2540 "change audio volume (256=normal)" , "volume" },
2541 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2542 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2543 "set sample format", "format" },
2544 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2545 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2546 "set channel layout", "layout" },
2547 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2548 "audio filters", "filter list" },
2550 /* subtitle options */
2551 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2552 "disable subtitle" },
2553 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2554 "force subtitle codec ('copy' to copy stream)", "codec" },
2555 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2556 , "force subtitle tag/fourcc", "fourcc/tag" },
2559 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2562 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2563 "set the maximum demux-decode delay", "seconds" },
2564 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2565 "set the initial demux-decode delay", "seconds" },
2567 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2568 "A comma-separated list of bitstream filters", "bitstream_filters" },
2570 /* data codec support */
2571 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2572 "force data codec ('copy' to copy stream)", "codec" },
2575 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2576 "set VAAPI hardware device (DRM path or X11 display name)", "device" },