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 const char *bsfs = NULL;
945 char *next, *codec_tag = NULL;
949 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
953 if (oc->nb_streams - 1 < o->nb_streamid_map)
954 st->id = o->streamid_map[oc->nb_streams - 1];
956 GROW_ARRAY(output_streams, nb_output_streams);
957 if (!(ost = av_mallocz(sizeof(*ost))))
959 output_streams[nb_output_streams - 1] = ost;
961 ost->file_index = nb_output_files - 1;
964 st->codecpar->codec_type = type;
965 choose_encoder(o, oc, ost);
967 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
969 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
972 ost->enc_ctx->codec_type = type;
975 AVIOContext *s = NULL;
976 char *buf = NULL, *arg = NULL, *preset = NULL;
978 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
980 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
981 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
984 if (!buf[0] || buf[0] == '#') {
988 if (!(arg = strchr(buf, '='))) {
989 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
993 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
995 } while (!s->eof_reached);
999 av_log(NULL, AV_LOG_FATAL,
1000 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1001 preset, ost->file_index, ost->index);
1005 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1008 ost->max_frames = INT64_MAX;
1009 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1011 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1012 while (bsfs && *bsfs) {
1013 const AVBitStreamFilter *filter;
1016 bsf = av_get_token(&bsfs, ",");
1020 filter = av_bsf_get_by_name(bsf);
1022 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1027 ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
1028 ost->nb_bitstream_filters + 1,
1029 sizeof(*ost->bitstream_filters));
1030 if (!ost->bitstream_filters)
1033 ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
1038 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1040 uint32_t tag = strtol(codec_tag, &next, 0);
1042 tag = AV_RL32(codec_tag);
1043 ost->enc_ctx->codec_tag = tag;
1046 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1048 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1049 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1052 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1053 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1055 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1057 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1059 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1060 ost->last_mux_dts = AV_NOPTS_VALUE;
1065 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1068 const char *p = str;
1075 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1082 /* read file contents into a string */
1083 static uint8_t *read_file(const char *filename)
1085 AVIOContext *pb = NULL;
1086 AVIOContext *dyn_buf = NULL;
1087 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1088 uint8_t buf[1024], *str;
1091 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1095 ret = avio_open_dyn_buf(&dyn_buf);
1100 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1101 avio_write(dyn_buf, buf, ret);
1102 avio_w8(dyn_buf, 0);
1105 ret = avio_close_dyn_buf(dyn_buf, &str);
1111 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1114 AVStream *st = ost->st;
1115 char *filter = NULL, *filter_script = NULL;
1117 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1118 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1120 if (filter_script && filter) {
1121 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1122 "output stream #%d:%d.\n", nb_output_files, st->index);
1127 return read_file(filter_script);
1129 return av_strdup(filter);
1131 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1135 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1139 AVCodecContext *video_enc;
1140 char *frame_aspect_ratio = NULL;
1142 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1144 video_enc = ost->enc_ctx;
1146 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1147 if (frame_aspect_ratio)
1148 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1150 if (!ost->stream_copy) {
1151 const char *p = NULL;
1152 char *frame_rate = NULL, *frame_size = NULL;
1153 char *frame_pix_fmt = NULL;
1154 char *intra_matrix = NULL, *inter_matrix = NULL;
1158 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1159 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1160 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1164 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1165 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1166 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1170 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1171 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1172 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1175 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1177 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1179 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1180 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1183 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1185 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1187 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1188 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1191 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1194 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1195 for (i = 0; p; i++) {
1197 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1199 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1202 video_enc->rc_override =
1203 av_realloc(video_enc->rc_override,
1204 sizeof(RcOverride) * (i + 1));
1205 if (!video_enc->rc_override) {
1206 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1209 video_enc->rc_override[i].start_frame = start;
1210 video_enc->rc_override[i].end_frame = end;
1212 video_enc->rc_override[i].qscale = q;
1213 video_enc->rc_override[i].quality_factor = 1.0;
1216 video_enc->rc_override[i].qscale = 0;
1217 video_enc->rc_override[i].quality_factor = -q/100.0;
1222 video_enc->rc_override_count = i;
1223 video_enc->intra_dc_precision = intra_dc_precision - 8;
1226 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1229 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1231 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1235 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1236 if (ost->logfile_prefix &&
1237 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1241 char logfilename[1024];
1244 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1245 ost->logfile_prefix ? ost->logfile_prefix :
1246 DEFAULT_PASS_LOGFILENAME_PREFIX,
1248 if (!strcmp(ost->enc->name, "libx264")) {
1249 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1251 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1252 f = fopen(logfilename, "wb");
1254 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1255 logfilename, strerror(errno));
1260 char *logbuffer = read_file(logfilename);
1263 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1267 video_enc->stats_in = logbuffer;
1272 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1273 if (ost->forced_keyframes)
1274 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1276 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1278 ost->top_field_first = -1;
1279 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1282 ost->avfilter = get_ost_filters(o, oc, ost);
1286 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1292 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1296 AVCodecContext *audio_enc;
1298 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1301 audio_enc = ost->enc_ctx;
1302 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1304 if (!ost->stream_copy) {
1305 char *sample_fmt = NULL;
1307 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1309 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1311 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1312 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1316 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1318 ost->avfilter = get_ost_filters(o, oc, ost);
1326 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1330 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1331 if (!ost->stream_copy) {
1332 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1339 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1341 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1342 ost->stream_copy = 1;
1347 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1350 AVCodecContext *subtitle_enc;
1352 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1353 subtitle_enc = ost->enc_ctx;
1355 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1360 /* arg format is "output-stream-index:streamid-value". */
1361 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1363 OptionsContext *o = optctx;
1368 av_strlcpy(idx_str, arg, sizeof(idx_str));
1369 p = strchr(idx_str, ':');
1371 av_log(NULL, AV_LOG_FATAL,
1372 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1377 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1378 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1379 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1383 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1385 AVFormatContext *is = ifile->ctx;
1386 AVFormatContext *os = ofile->ctx;
1390 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1392 return AVERROR(ENOMEM);
1395 for (i = 0; i < is->nb_chapters; i++) {
1396 AVChapter *in_ch = is->chapters[i], *out_ch;
1397 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1398 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1399 AV_TIME_BASE_Q, in_ch->time_base);
1400 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1401 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1404 if (in_ch->end < ts_off)
1406 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1409 out_ch = av_mallocz(sizeof(AVChapter));
1411 return AVERROR(ENOMEM);
1413 out_ch->id = in_ch->id;
1414 out_ch->time_base = in_ch->time_base;
1415 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1416 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1419 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1421 os->chapters[os->nb_chapters++] = out_ch;
1426 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1427 AVFormatContext *oc)
1431 switch (ofilter->type) {
1432 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1433 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1435 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1440 ost->source_index = -1;
1441 ost->filter = ofilter;
1445 if (ost->stream_copy) {
1446 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1447 "which is fed from a complex filtergraph. Filtering and streamcopy "
1448 "cannot be used together.\n", ost->file_index, ost->index);
1452 avfilter_inout_free(&ofilter->out_tmp);
1455 static int init_complex_filters(void)
1459 for (i = 0; i < nb_filtergraphs; i++) {
1460 ret = init_complex_filtergraph(filtergraphs[i]);
1467 static int configure_complex_filters(void)
1471 for (i = 0; i < nb_filtergraphs; i++)
1472 if (!filtergraphs[i]->graph &&
1473 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1478 static int open_output_file(OptionsContext *o, const char *filename)
1480 AVFormatContext *oc;
1482 AVOutputFormat *file_oformat;
1486 AVDictionary *unused_opts = NULL;
1487 AVDictionaryEntry *e = NULL;
1489 GROW_ARRAY(output_files, nb_output_files);
1490 of = av_mallocz(sizeof(*of));
1493 output_files[nb_output_files - 1] = of;
1495 of->ost_index = nb_output_streams;
1496 of->recording_time = o->recording_time;
1497 of->start_time = o->start_time;
1498 of->limit_filesize = o->limit_filesize;
1499 of->shortest = o->shortest;
1500 av_dict_copy(&of->opts, o->g->format_opts, 0);
1502 if (!strcmp(filename, "-"))
1505 oc = avformat_alloc_context();
1507 print_error(filename, AVERROR(ENOMEM));
1511 if (o->recording_time != INT64_MAX)
1512 oc->duration = o->recording_time;
1515 file_oformat = av_guess_format(o->format, NULL, NULL);
1516 if (!file_oformat) {
1517 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1521 file_oformat = av_guess_format(NULL, filename, NULL);
1522 if (!file_oformat) {
1523 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1529 oc->oformat = file_oformat;
1530 oc->interrupt_callback = int_cb;
1531 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1533 /* create streams for all unlabeled output pads */
1534 for (i = 0; i < nb_filtergraphs; i++) {
1535 FilterGraph *fg = filtergraphs[i];
1536 for (j = 0; j < fg->nb_outputs; j++) {
1537 OutputFilter *ofilter = fg->outputs[j];
1539 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1542 switch (ofilter->type) {
1543 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1544 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1545 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1547 init_output_filter(ofilter, o, oc);
1551 if (!o->nb_stream_maps) {
1552 /* pick the "best" stream of each type */
1553 #define NEW_STREAM(type, index)\
1555 ost = new_ ## type ## _stream(o, oc);\
1556 ost->source_index = index;\
1557 ost->sync_ist = input_streams[index];\
1558 input_streams[index]->discard = 0;\
1559 input_streams[index]->st->discard = AVDISCARD_NONE;\
1562 /* video: highest resolution */
1563 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1564 int area = 0, idx = -1;
1565 for (i = 0; i < nb_input_streams; i++) {
1566 ist = input_streams[i];
1567 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1568 ist->st->codecpar->width * ist->st->codecpar->height > area) {
1569 area = ist->st->codecpar->width * ist->st->codecpar->height;
1573 NEW_STREAM(video, idx);
1576 /* audio: most channels */
1577 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1578 int channels = 0, idx = -1;
1579 for (i = 0; i < nb_input_streams; i++) {
1580 ist = input_streams[i];
1581 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1582 ist->st->codecpar->channels > channels) {
1583 channels = ist->st->codecpar->channels;
1587 NEW_STREAM(audio, idx);
1590 /* subtitles: pick first */
1591 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1592 for (i = 0; i < nb_input_streams; i++)
1593 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1594 NEW_STREAM(subtitle, i);
1598 /* do something with data? */
1600 for (i = 0; i < o->nb_stream_maps; i++) {
1601 StreamMap *map = &o->stream_maps[i];
1606 if (map->linklabel) {
1608 OutputFilter *ofilter = NULL;
1611 for (j = 0; j < nb_filtergraphs; j++) {
1612 fg = filtergraphs[j];
1613 for (k = 0; k < fg->nb_outputs; k++) {
1614 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1615 if (out && !strcmp(out->name, map->linklabel)) {
1616 ofilter = fg->outputs[k];
1623 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1624 "in any defined filter graph.\n", map->linklabel);
1627 init_output_filter(ofilter, o, oc);
1629 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1630 switch (ist->st->codecpar->codec_type) {
1631 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1632 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1633 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1634 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1635 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1637 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1638 map->file_index, map->stream_index);
1642 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1643 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1644 map->sync_stream_index];
1646 ist->st->discard = AVDISCARD_NONE;
1651 /* handle attached files */
1652 for (i = 0; i < o->nb_attachments; i++) {
1654 uint8_t *attachment;
1658 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1659 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1663 if ((len = avio_size(pb)) <= 0) {
1664 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1668 if (!(attachment = av_malloc(len))) {
1669 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1673 avio_read(pb, attachment, len);
1675 ost = new_attachment_stream(o, oc);
1676 ost->stream_copy = 0;
1677 ost->source_index = -1;
1678 ost->attachment_filename = o->attachments[i];
1679 ost->st->codecpar->extradata = attachment;
1680 ost->st->codecpar->extradata_size = len;
1682 p = strrchr(o->attachments[i], '/');
1683 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1687 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1688 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1689 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1693 /* check if all codec options have been used */
1694 unused_opts = strip_specifiers(o->g->codec_opts);
1695 for (i = of->ost_index; i < nb_output_streams; i++) {
1697 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1698 AV_DICT_IGNORE_SUFFIX)))
1699 av_dict_set(&unused_opts, e->key, NULL, 0);
1703 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1704 const AVClass *class = avcodec_get_class();
1705 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1706 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1709 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1710 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1711 "output file #%d (%s) is not an encoding option.\n", e->key,
1712 option->help ? option->help : "", nb_output_files - 1,
1717 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1718 "output file #%d (%s) has not been used for any stream. The most "
1719 "likely reason is either wrong type (e.g. a video option with "
1720 "no video streams) or that it is a private option of some encoder "
1721 "which was not actually used for any stream.\n", e->key,
1722 option->help ? option->help : "", nb_output_files - 1, filename);
1724 av_dict_free(&unused_opts);
1726 /* set the encoding/decoding_needed flags */
1727 for (i = of->ost_index; i < nb_output_streams; i++) {
1728 OutputStream *ost = output_streams[i];
1730 ost->encoding_needed = !ost->stream_copy;
1731 if (ost->encoding_needed && ost->source_index >= 0) {
1732 InputStream *ist = input_streams[ost->source_index];
1733 ist->decoding_needed = 1;
1737 /* check filename in case of an image number is expected */
1738 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1739 if (!av_filename_number_test(oc->filename)) {
1740 print_error(oc->filename, AVERROR(EINVAL));
1745 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1746 /* test if it already exists to avoid losing precious files */
1747 assert_file_overwrite(filename);
1750 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1751 &oc->interrupt_callback,
1753 print_error(filename, err);
1758 if (o->mux_preload) {
1760 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1761 av_dict_set(&of->opts, "preload", buf, 0);
1763 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1764 oc->flags |= AVFMT_FLAG_NONBLOCK;
1767 for (i = 0; i < o->nb_metadata_map; i++) {
1769 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1771 if (in_file_index >= nb_input_files) {
1772 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1775 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1776 in_file_index >= 0 ?
1777 input_files[in_file_index]->ctx : NULL, o);
1781 if (o->chapters_input_file >= nb_input_files) {
1782 if (o->chapters_input_file == INT_MAX) {
1783 /* copy chapters from the first input file that has them*/
1784 o->chapters_input_file = -1;
1785 for (i = 0; i < nb_input_files; i++)
1786 if (input_files[i]->ctx->nb_chapters) {
1787 o->chapters_input_file = i;
1791 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1792 o->chapters_input_file);
1796 if (o->chapters_input_file >= 0)
1797 copy_chapters(input_files[o->chapters_input_file], of,
1798 !o->metadata_chapters_manual);
1800 /* copy global metadata by default */
1801 if (!o->metadata_global_manual && nb_input_files)
1802 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1803 AV_DICT_DONT_OVERWRITE);
1804 if (!o->metadata_streams_manual)
1805 for (i = of->ost_index; i < nb_output_streams; i++) {
1807 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1809 ist = input_streams[output_streams[i]->source_index];
1810 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1813 /* process manually set metadata */
1814 for (i = 0; i < o->nb_metadata; i++) {
1817 const char *stream_spec;
1818 int index = 0, j, ret;
1820 val = strchr(o->metadata[i].u.str, '=');
1822 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1823 o->metadata[i].u.str);
1828 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1830 for (j = 0; j < oc->nb_streams; j++) {
1831 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1832 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1843 if (index < 0 || index >= oc->nb_chapters) {
1844 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1847 m = &oc->chapters[index]->metadata;
1850 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1853 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1860 static int opt_target(void *optctx, const char *opt, const char *arg)
1862 OptionsContext *o = optctx;
1863 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1864 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1866 if (!strncmp(arg, "pal-", 4)) {
1869 } else if (!strncmp(arg, "ntsc-", 5)) {
1872 } else if (!strncmp(arg, "film-", 5)) {
1876 /* Try to determine PAL/NTSC by peeking in the input files */
1877 if (nb_input_files) {
1879 for (j = 0; j < nb_input_files; j++) {
1880 for (i = 0; i < input_files[j]->nb_streams; i++) {
1881 AVStream *st = input_files[j]->ctx->streams[i];
1882 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1884 fr = st->time_base.den * 1000 / st->time_base.num;
1888 } else if ((fr == 29970) || (fr == 23976)) {
1893 if (norm != UNKNOWN)
1897 if (norm != UNKNOWN)
1898 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1901 if (norm == UNKNOWN) {
1902 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1903 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1904 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1908 if (!strcmp(arg, "vcd")) {
1909 opt_video_codec(o, "c:v", "mpeg1video");
1910 opt_audio_codec(o, "c:a", "mp2");
1911 parse_option(o, "f", "vcd", options);
1913 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1914 parse_option(o, "r", frame_rates[norm], options);
1915 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1917 opt_default(NULL, "b", "1150000");
1918 opt_default(NULL, "maxrate", "1150000");
1919 opt_default(NULL, "minrate", "1150000");
1920 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1922 opt_default(NULL, "b:a", "224000");
1923 parse_option(o, "ar", "44100", options);
1924 parse_option(o, "ac", "2", options);
1926 opt_default(NULL, "packetsize", "2324");
1927 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1929 /* We have to offset the PTS, so that it is consistent with the SCR.
1930 SCR starts at 36000, but the first two packs contain only padding
1931 and the first pack from the other stream, respectively, may also have
1932 been written before.
1933 So the real data starts at SCR 36000+3*1200. */
1934 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1935 } else if (!strcmp(arg, "svcd")) {
1937 opt_video_codec(o, "c:v", "mpeg2video");
1938 opt_audio_codec(o, "c:a", "mp2");
1939 parse_option(o, "f", "svcd", options);
1941 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1942 parse_option(o, "r", frame_rates[norm], options);
1943 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1945 opt_default(NULL, "b", "2040000");
1946 opt_default(NULL, "maxrate", "2516000");
1947 opt_default(NULL, "minrate", "0"); // 1145000;
1948 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1949 opt_default(NULL, "scan_offset", "1");
1952 opt_default(NULL, "b:a", "224000");
1953 parse_option(o, "ar", "44100", options);
1955 opt_default(NULL, "packetsize", "2324");
1957 } else if (!strcmp(arg, "dvd")) {
1959 opt_video_codec(o, "c:v", "mpeg2video");
1960 opt_audio_codec(o, "c:a", "ac3");
1961 parse_option(o, "f", "dvd", options);
1963 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1964 parse_option(o, "r", frame_rates[norm], options);
1965 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1967 opt_default(NULL, "b", "6000000");
1968 opt_default(NULL, "maxrate", "9000000");
1969 opt_default(NULL, "minrate", "0"); // 1500000;
1970 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1972 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1973 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1975 opt_default(NULL, "b:a", "448000");
1976 parse_option(o, "ar", "48000", options);
1978 } else if (!strncmp(arg, "dv", 2)) {
1980 parse_option(o, "f", "dv", options);
1982 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1983 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1984 norm == PAL ? "yuv420p" : "yuv411p", options);
1985 parse_option(o, "r", frame_rates[norm], options);
1987 parse_option(o, "ar", "48000", options);
1988 parse_option(o, "ac", "2", options);
1991 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1992 return AVERROR(EINVAL);
1995 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1996 av_dict_copy(&o->g->format_opts, format_opts, 0);
2001 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2003 av_free (vstats_filename);
2004 vstats_filename = av_strdup (arg);
2008 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2011 time_t today2 = time(NULL);
2012 struct tm *today = localtime(&today2);
2014 if (!today) { // maybe tomorrow
2015 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2019 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2021 return opt_vstats_file(NULL, opt, filename);
2024 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2026 OptionsContext *o = optctx;
2027 return parse_option(o, "frames:v", arg, options);
2030 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2032 OptionsContext *o = optctx;
2033 return parse_option(o, "frames:a", arg, options);
2036 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2038 OptionsContext *o = optctx;
2039 return parse_option(o, "frames:d", arg, options);
2042 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2044 OptionsContext *o = optctx;
2045 return parse_option(o, "tag:v", arg, options);
2048 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2050 OptionsContext *o = optctx;
2051 return parse_option(o, "tag:a", arg, options);
2054 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2056 OptionsContext *o = optctx;
2057 return parse_option(o, "tag:s", arg, options);
2060 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2062 OptionsContext *o = optctx;
2063 return parse_option(o, "filter:v", arg, options);
2066 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2068 OptionsContext *o = optctx;
2069 return parse_option(o, "filter:a", arg, options);
2072 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2074 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2075 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2076 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2078 if (video_sync_method == VSYNC_AUTO)
2079 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2083 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2085 OptionsContext *o = optctx;
2086 char layout_str[32];
2089 int ret, channels, ac_str_size;
2092 layout = av_get_channel_layout(arg);
2094 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2095 return AVERROR(EINVAL);
2097 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2098 ret = opt_default(NULL, opt, layout_str);
2102 /* set 'ac' option based on channel layout */
2103 channels = av_get_channel_layout_nb_channels(layout);
2104 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2105 stream_str = strchr(opt, ':');
2106 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2107 ac_str = av_mallocz(ac_str_size);
2109 return AVERROR(ENOMEM);
2110 av_strlcpy(ac_str, "ac", 3);
2112 av_strlcat(ac_str, stream_str, ac_str_size);
2113 ret = parse_option(o, ac_str, layout_str, options);
2119 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2121 OptionsContext *o = optctx;
2122 return parse_option(o, "q:a", arg, options);
2125 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2127 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2128 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2129 return AVERROR(ENOMEM);
2130 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2131 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2132 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2133 return AVERROR(ENOMEM);
2137 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2139 uint8_t *graph_desc = read_file(arg);
2141 return AVERROR(EINVAL);
2143 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2144 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2145 return AVERROR(ENOMEM);
2146 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2147 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2151 void show_help_default(const char *opt, const char *arg)
2153 /* per-file options have at least one of those set */
2154 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2155 int show_advanced = 0, show_avoptions = 0;
2158 if (!strcmp(opt, "long"))
2160 else if (!strcmp(opt, "full"))
2161 show_advanced = show_avoptions = 1;
2163 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2168 printf("Getting help:\n"
2169 " -h -- print basic options\n"
2170 " -h long -- print more options\n"
2171 " -h full -- print all options (including all format and codec specific options, very long)\n"
2172 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2173 " See man %s for detailed description of the options.\n"
2174 "\n", program_name);
2176 show_help_options(options, "Print help / information / capabilities:",
2179 show_help_options(options, "Global options (affect whole program "
2180 "instead of just one file:",
2181 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2183 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2184 per_file | OPT_EXIT, 0);
2186 show_help_options(options, "Per-file main options:", 0,
2187 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2188 OPT_EXIT, per_file);
2190 show_help_options(options, "Advanced per-file options:",
2191 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2193 show_help_options(options, "Video options:",
2194 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2196 show_help_options(options, "Advanced Video options:",
2197 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2199 show_help_options(options, "Audio options:",
2200 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2202 show_help_options(options, "Advanced Audio options:",
2203 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2204 show_help_options(options, "Subtitle options:",
2205 OPT_SUBTITLE, 0, 0);
2208 if (show_avoptions) {
2209 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2210 show_help_children(avcodec_get_class(), flags);
2211 show_help_children(avformat_get_class(), flags);
2212 show_help_children(sws_get_class(), flags);
2213 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2217 void show_usage(void)
2219 printf("Hyper fast Audio and Video encoder\n");
2220 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2229 static const OptionGroupDef groups[] = {
2230 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2231 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2234 static int open_files(OptionGroupList *l, const char *inout,
2235 int (*open_file)(OptionsContext*, const char*))
2239 for (i = 0; i < l->nb_groups; i++) {
2240 OptionGroup *g = &l->groups[i];
2246 ret = parse_optgroup(&o, g);
2248 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2249 "%s.\n", inout, g->arg);
2253 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2254 ret = open_file(&o, g->arg);
2257 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2261 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2267 int avconv_parse_options(int argc, char **argv)
2269 OptionParseContext octx;
2273 memset(&octx, 0, sizeof(octx));
2275 /* split the commandline into an internal representation */
2276 ret = split_commandline(&octx, argc, argv, options, groups,
2277 FF_ARRAY_ELEMS(groups));
2279 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2283 /* apply global options */
2284 ret = parse_optgroup(NULL, &octx.global_opts);
2286 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2290 /* open input files */
2291 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2293 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2297 /* create the complex filtergraphs */
2298 ret = init_complex_filters();
2300 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2304 /* open output files */
2305 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2307 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2311 /* configure the complex filtergraphs */
2312 ret = configure_complex_filters();
2314 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2319 uninit_parse_context(&octx);
2321 av_strerror(ret, error, sizeof(error));
2322 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2327 #define OFFSET(x) offsetof(OptionsContext, x)
2328 const OptionDef options[] = {
2330 #include "cmdutils_common_opts.h"
2331 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2332 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2333 "force format", "fmt" },
2334 { "y", OPT_BOOL, { &file_overwrite },
2335 "overwrite output files" },
2336 { "n", OPT_BOOL, { &file_skip },
2337 "never overwrite output files" },
2338 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2339 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2340 "codec name", "codec" },
2341 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2342 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2343 "codec name", "codec" },
2344 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2345 OPT_OUTPUT, { .off = OFFSET(presets) },
2346 "preset name", "preset" },
2347 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2348 OPT_OUTPUT, { .func_arg = opt_map },
2349 "set input stream mapping",
2350 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2351 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2352 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2353 "set metadata information of outfile from infile",
2354 "outfile[,metadata]:infile[,metadata]" },
2355 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2356 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2357 "set chapters mapping", "input_file_index" },
2358 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2359 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2360 "record or transcode \"duration\" seconds of audio/video",
2362 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2363 "set the limit file size in bytes", "limit_size" },
2364 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2365 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2366 "set the start time offset", "time_off" },
2367 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2368 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2369 "enable/disable accurate seeking with -ss" },
2370 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2371 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2372 "set the input ts offset", "time_off" },
2373 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2374 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2375 "set the input ts scale", "scale" },
2376 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2377 "add metadata", "string=string" },
2378 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2379 OPT_OUTPUT, { .func_arg = opt_data_frames },
2380 "set the number of data frames to record", "number" },
2381 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2382 "add timings for benchmarking" },
2383 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2384 "set max runtime in seconds", "limit" },
2385 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2386 "dump each input packet" },
2387 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2388 "when dumping packets, also dump the payload" },
2389 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2390 OPT_INPUT, { .off = OFFSET(rate_emu) },
2391 "read input at native frame rate", "" },
2392 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2393 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2394 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2395 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2396 "video sync method", "" },
2397 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2398 "audio sync method", "" },
2399 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2400 "audio drift threshold", "threshold" },
2401 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2402 "copy timestamps" },
2403 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2404 "copy input stream time base when stream copying" },
2405 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2406 OPT_OUTPUT, { .off = OFFSET(shortest) },
2407 "finish encoding within shortest input" },
2408 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2409 "timestamp discontinuity delta threshold", "threshold" },
2410 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2411 "exit on error", "error" },
2412 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2413 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2414 "copy initial non-keyframes" },
2415 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2416 "set the number of frames to record", "number" },
2417 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2418 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2419 "force codec tag/fourcc", "fourcc/tag" },
2420 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2421 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2422 "use fixed quality scale (VBR)", "q" },
2423 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2424 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2425 "use fixed quality scale (VBR)", "q" },
2426 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2427 "set stream filterchain", "filter_list" },
2428 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2429 "read stream filtergraph description from a file", "filename" },
2430 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2431 "create a complex filtergraph", "graph_description" },
2432 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2433 "read complex filtergraph description from a file", "filename" },
2434 { "stats", OPT_BOOL, { &print_stats },
2435 "print progress report during encoding", },
2436 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2437 OPT_OUTPUT, { .func_arg = opt_attach },
2438 "add an attachment to the output file", "filename" },
2439 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2440 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2441 "extract an attachment into a file", "filename" },
2442 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2443 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2446 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2447 "set the number of video frames to record", "number" },
2448 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2449 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2450 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2451 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2452 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2453 "set frame size (WxH or abbreviation)", "size" },
2454 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2455 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2456 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2457 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2458 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2459 "set pixel format", "format" },
2460 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2462 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2463 "discard threshold", "n" },
2464 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2465 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2466 "rate control override for specific intervals", "override" },
2467 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2468 OPT_OUTPUT, { .func_arg = opt_video_codec },
2469 "force video codec ('copy' to copy stream)", "codec" },
2470 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2471 "select the pass number (1 or 2)", "n" },
2472 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2473 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2474 "select two pass log file name prefix", "prefix" },
2475 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2476 "dump video coding statistics to file" },
2477 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2478 "dump video coding statistics to file", "file" },
2479 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2480 "video filters", "filter list" },
2481 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2482 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2483 "specify intra matrix coeffs", "matrix" },
2484 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2485 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2486 "specify inter matrix coeffs", "matrix" },
2487 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2488 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2489 "top=1/bottom=0/auto=-1 field first", "" },
2490 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2491 "intra_dc_precision", "precision" },
2492 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2493 OPT_OUTPUT, { .func_arg = opt_video_tag },
2494 "force video tag/fourcc", "fourcc/tag" },
2495 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2496 "show QP histogram" },
2497 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2498 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2499 "force the selected framerate, disable the best supported framerate selection" },
2500 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2501 OPT_OUTPUT, { .func_arg = opt_streamid },
2502 "set the value of an outfile streamid", "streamIndex:value" },
2503 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2504 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2505 "force key frames at specified timestamps", "timestamps" },
2506 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2507 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2508 "use HW accelerated decoding", "hwaccel name" },
2509 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2510 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2511 "select a device for HW acceleration", "devicename" },
2512 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2513 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
2514 "select output format used with HW accelerated decoding", "format" },
2516 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2517 "show available HW acceleration methods" },
2518 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2519 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2520 "automatically insert correct rotate filters" },
2521 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
2522 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2525 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2526 "set the number of audio frames to record", "number" },
2527 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2528 "set audio quality (codec-specific)", "quality", },
2529 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2530 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2531 "set audio sampling rate (in Hz)", "rate" },
2532 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2533 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2534 "set number of audio channels", "channels" },
2535 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2537 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2538 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2539 "force audio codec ('copy' to copy stream)", "codec" },
2540 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2541 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2542 "force audio tag/fourcc", "fourcc/tag" },
2543 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2544 "change audio volume (256=normal)" , "volume" },
2545 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2546 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2547 "set sample format", "format" },
2548 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2549 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2550 "set channel layout", "layout" },
2551 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2552 "audio filters", "filter list" },
2554 /* subtitle options */
2555 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2556 "disable subtitle" },
2557 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2558 "force subtitle codec ('copy' to copy stream)", "codec" },
2559 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2560 , "force subtitle tag/fourcc", "fourcc/tag" },
2563 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2566 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2567 "set the maximum demux-decode delay", "seconds" },
2568 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2569 "set the initial demux-decode delay", "seconds" },
2571 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2572 "A comma-separated list of bitstream filters", "bitstream_filters" },
2574 /* data codec support */
2575 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2576 "force data codec ('copy' to copy stream)", "codec" },
2579 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2580 "set VAAPI hardware device (DRM path or X11 display name)", "device" },