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 },
74 char *vstats_filename;
76 float audio_drift_threshold = 0.1;
77 float dts_delta_threshold = 10;
79 int audio_volume = 256;
80 int audio_sync_method = 0;
81 int video_sync_method = VSYNC_AUTO;
87 int exit_on_error = 0;
91 static int file_overwrite = 0;
92 static int file_skip = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int using_stdin = 0;
96 static int input_sync;
98 static void uninit_options(OptionsContext *o)
100 const OptionDef *po = options;
103 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
105 void *dst = (uint8_t*)o + po->u.off;
107 if (po->flags & OPT_SPEC) {
108 SpecifierOpt **so = dst;
109 int i, *count = (int*)(so + 1);
110 for (i = 0; i < *count; i++) {
111 av_freep(&(*so)[i].specifier);
112 if (po->flags & OPT_STRING)
113 av_freep(&(*so)[i].u.str);
117 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
122 for (i = 0; i < o->nb_stream_maps; i++)
123 av_freep(&o->stream_maps[i].linklabel);
124 av_freep(&o->stream_maps);
125 av_freep(&o->meta_data_maps);
126 av_freep(&o->streamid_map);
129 static void init_options(OptionsContext *o)
131 memset(o, 0, sizeof(*o));
133 o->mux_max_delay = 0.7;
134 o->start_time = AV_NOPTS_VALUE;
135 o->recording_time = INT64_MAX;
136 o->limit_filesize = UINT64_MAX;
137 o->chapters_input_file = INT_MAX;
138 o->accurate_seek = 1;
141 /* return a copy of the input with the stream specifiers removed from the keys */
142 static AVDictionary *strip_specifiers(AVDictionary *dict)
144 AVDictionaryEntry *e = NULL;
145 AVDictionary *ret = NULL;
147 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
148 char *p = strchr(e->key, ':');
152 av_dict_set(&ret, e->key, e->value, 0);
159 static double parse_frame_aspect_ratio(const char *arg)
166 p = strchr(arg, ':');
168 x = strtol(arg, &end, 10);
170 y = strtol(end + 1, &end, 10);
172 ar = (double)x / (double)y;
174 ar = strtod(arg, NULL);
177 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
183 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
187 printf("Supported hardware acceleration:\n");
188 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
189 printf("%s\n", hwaccels[i].name);
195 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:a", arg, options);
201 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:v", arg, options);
207 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:s", arg, options);
213 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:d", arg, options);
219 static int opt_map(void *optctx, const char *opt, const char *arg)
221 OptionsContext *o = optctx;
223 int i, negative = 0, file_idx;
224 int sync_file_idx = -1, sync_stream_idx;
232 map = av_strdup(arg);
234 return AVERROR(ENOMEM);
236 /* parse sync stream first, just pick first matching stream */
237 if (sync = strchr(map, ',')) {
239 sync_file_idx = strtol(sync + 1, &sync, 0);
240 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
246 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
247 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
248 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
252 if (i == input_files[sync_file_idx]->nb_streams) {
253 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
254 "match any streams.\n", arg);
261 /* this mapping refers to lavfi output */
262 const char *c = map + 1;
263 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
264 m = &o->stream_maps[o->nb_stream_maps - 1];
265 m->linklabel = av_get_token(&c, "]");
267 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
271 file_idx = strtol(map, &p, 0);
272 if (file_idx >= nb_input_files || file_idx < 0) {
273 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
277 /* disable some already defined maps */
278 for (i = 0; i < o->nb_stream_maps; i++) {
279 m = &o->stream_maps[i];
280 if (file_idx == m->file_index &&
281 check_stream_specifier(input_files[m->file_index]->ctx,
282 input_files[m->file_index]->ctx->streams[m->stream_index],
283 *p == ':' ? p + 1 : p) > 0)
287 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
288 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
289 *p == ':' ? p + 1 : p) <= 0)
291 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
292 m = &o->stream_maps[o->nb_stream_maps - 1];
294 m->file_index = file_idx;
297 if (sync_file_idx >= 0) {
298 m->sync_file_index = sync_file_idx;
299 m->sync_stream_index = sync_stream_idx;
301 m->sync_file_index = file_idx;
302 m->sync_stream_index = i;
308 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
316 static int opt_attach(void *optctx, const char *opt, const char *arg)
318 OptionsContext *o = optctx;
319 GROW_ARRAY(o->attachments, o->nb_attachments);
320 o->attachments[o->nb_attachments - 1] = arg;
325 * Parse a metadata specifier passed as 'arg' parameter.
326 * @param arg metadata string to parse
327 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
328 * @param index for type c/p, chapter/program index is written here
329 * @param stream_spec for type s, the stream specifier is written here
331 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
339 if (*(++arg) && *arg != ':') {
340 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
343 *stream_spec = *arg == ':' ? arg + 1 : "";
348 *index = strtol(++arg, NULL, 0);
351 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
358 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
360 AVDictionary **meta_in = NULL;
361 AVDictionary **meta_out;
363 char type_in, type_out;
364 const char *istream_spec = NULL, *ostream_spec = NULL;
365 int idx_in = 0, idx_out = 0;
367 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
368 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
370 if (type_in == 'g' || type_out == 'g')
371 o->metadata_global_manual = 1;
372 if (type_in == 's' || type_out == 's')
373 o->metadata_streams_manual = 1;
374 if (type_in == 'c' || type_out == 'c')
375 o->metadata_chapters_manual = 1;
377 /* ic is NULL when just disabling automatic mappings */
381 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
382 if ((index) < 0 || (index) >= (nb_elems)) {\
383 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
388 #define SET_DICT(type, meta, context, index)\
391 meta = &context->metadata;\
394 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
395 meta = &context->chapters[index]->metadata;\
398 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
399 meta = &context->programs[index]->metadata;\
402 break; /* handled separately below */ \
403 default: av_assert0(0);\
406 SET_DICT(type_in, meta_in, ic, idx_in);
407 SET_DICT(type_out, meta_out, oc, idx_out);
409 /* for input streams choose first matching stream */
410 if (type_in == 's') {
411 for (i = 0; i < ic->nb_streams; i++) {
412 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
413 meta_in = &ic->streams[i]->metadata;
419 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
424 if (type_out == 's') {
425 for (i = 0; i < oc->nb_streams; i++) {
426 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
427 meta_out = &oc->streams[i]->metadata;
428 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
433 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
438 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
440 const AVCodecDescriptor *desc;
441 const char *codec_string = encoder ? "encoder" : "decoder";
445 avcodec_find_encoder_by_name(name) :
446 avcodec_find_decoder_by_name(name);
448 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
449 codec = encoder ? avcodec_find_encoder(desc->id) :
450 avcodec_find_decoder(desc->id);
452 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
453 codec_string, codec->name, desc->name);
457 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
460 if (codec->type != type) {
461 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
467 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
469 char *codec_name = NULL;
471 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
473 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
474 st->codecpar->codec_id = codec->id;
477 return avcodec_find_decoder(st->codecpar->codec_id);
480 /* Add all the streams from the given input file to the global
481 * list of input streams. */
482 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
486 for (i = 0; i < ic->nb_streams; i++) {
487 AVStream *st = ic->streams[i];
488 AVCodecParameters *par = st->codecpar;
489 InputStream *ist = av_mallocz(sizeof(*ist));
490 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
491 char *codec_tag = NULL;
497 GROW_ARRAY(input_streams, nb_input_streams);
498 input_streams[nb_input_streams - 1] = ist;
501 ist->file_index = nb_input_files;
503 st->discard = AVDISCARD_ALL;
505 ist->min_pts = INT64_MAX;
506 ist->max_pts = INT64_MIN;
509 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
512 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
514 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
516 uint32_t tag = strtol(codec_tag, &next, 0);
518 tag = AV_RL32(codec_tag);
519 st->codecpar->codec_tag = tag;
522 ist->dec = choose_decoder(o, ic, st);
523 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
525 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
527 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
531 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
533 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
537 switch (par->codec_type) {
538 case AVMEDIA_TYPE_VIDEO:
539 ist->resample_height = ist->dec_ctx->height;
540 ist->resample_width = ist->dec_ctx->width;
541 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
543 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
544 if (framerate && av_parse_video_rate(&ist->framerate,
546 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
551 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
553 if (!strcmp(hwaccel, "none"))
554 ist->hwaccel_id = HWACCEL_NONE;
555 else if (!strcmp(hwaccel, "auto"))
556 ist->hwaccel_id = HWACCEL_AUTO;
559 for (i = 0; hwaccels[i].name; i++) {
560 if (!strcmp(hwaccels[i].name, hwaccel)) {
561 ist->hwaccel_id = hwaccels[i].id;
566 if (!ist->hwaccel_id) {
567 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
569 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
570 for (i = 0; hwaccels[i].name; i++)
571 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
572 av_log(NULL, AV_LOG_FATAL, "\n");
578 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
579 if (hwaccel_device) {
580 ist->hwaccel_device = av_strdup(hwaccel_device);
581 if (!ist->hwaccel_device)
584 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
587 case AVMEDIA_TYPE_AUDIO:
588 guess_input_channel_layout(ist);
590 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
591 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
592 ist->resample_channels = ist->dec_ctx->channels;
593 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
596 case AVMEDIA_TYPE_DATA:
597 case AVMEDIA_TYPE_SUBTITLE:
598 case AVMEDIA_TYPE_ATTACHMENT:
599 case AVMEDIA_TYPE_UNKNOWN:
607 static void assert_file_overwrite(const char *filename)
609 if (file_overwrite && file_skip) {
610 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
614 if (!file_overwrite &&
615 (!strchr(filename, ':') || filename[1] == ':' ||
616 av_strstart(filename, "file:", NULL))) {
617 if (avio_check(filename, 0) == 0) {
618 if (!using_stdin && !file_skip) {
619 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
622 fprintf(stderr, "Not overwriting - exiting\n");
627 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
634 static void dump_attachment(AVStream *st, const char *filename)
637 AVIOContext *out = NULL;
638 AVDictionaryEntry *e;
640 if (!st->codecpar->extradata_size) {
641 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
642 nb_input_files - 1, st->index);
645 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
648 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
649 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
653 assert_file_overwrite(filename);
655 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
656 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
661 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
666 static int open_input_file(OptionsContext *o, const char *filename)
670 AVInputFormat *file_iformat = NULL;
675 AVDictionary *unused_opts = NULL;
676 AVDictionaryEntry *e = NULL;
677 int orig_nb_streams; // number of streams before avformat_find_stream_info
680 if (!(file_iformat = av_find_input_format(o->format))) {
681 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
686 if (!strcmp(filename, "-"))
689 using_stdin |= !strncmp(filename, "pipe:", 5) ||
690 !strcmp(filename, "/dev/stdin");
692 /* get default parameters from command line */
693 ic = avformat_alloc_context();
695 print_error(filename, AVERROR(ENOMEM));
698 if (o->nb_audio_sample_rate) {
699 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
700 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
702 if (o->nb_audio_channels) {
703 /* because we set audio_channels based on both the "ac" and
704 * "channel_layout" options, we need to check that the specified
705 * demuxer actually has the "channels" option before setting it */
706 if (file_iformat && file_iformat->priv_class &&
707 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
708 AV_OPT_SEARCH_FAKE_OBJ)) {
709 snprintf(buf, sizeof(buf), "%d",
710 o->audio_channels[o->nb_audio_channels - 1].u.i);
711 av_dict_set(&o->g->format_opts, "channels", buf, 0);
714 if (o->nb_frame_rates) {
715 /* set the format-level framerate option;
716 * this is important for video grabbers, e.g. x11 */
717 if (file_iformat && file_iformat->priv_class &&
718 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
719 AV_OPT_SEARCH_FAKE_OBJ)) {
720 av_dict_set(&o->g->format_opts, "framerate",
721 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
724 if (o->nb_frame_sizes) {
725 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
727 if (o->nb_frame_pix_fmts)
728 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
730 ic->flags |= AVFMT_FLAG_NONBLOCK;
731 ic->interrupt_callback = int_cb;
733 /* open the input file with generic libav function */
734 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
736 print_error(filename, err);
739 assert_avoptions(o->g->format_opts);
741 /* apply forced codec ids */
742 for (i = 0; i < ic->nb_streams; i++)
743 choose_decoder(o, ic, ic->streams[i]);
745 /* Set AVCodecContext options for avformat_find_stream_info */
746 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
747 orig_nb_streams = ic->nb_streams;
749 /* If not enough info to get the stream parameters, we decode the
750 first frames to get it. (used in mpeg case for example) */
751 ret = avformat_find_stream_info(ic, opts);
753 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
754 avformat_close_input(&ic);
758 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
759 /* add the stream start time */
760 if (ic->start_time != AV_NOPTS_VALUE)
761 timestamp += ic->start_time;
763 /* if seeking requested, we execute it */
764 if (o->start_time != AV_NOPTS_VALUE) {
765 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
767 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
768 filename, (double)timestamp / AV_TIME_BASE);
772 /* update the current parameters so that they match the one of the input stream */
773 add_input_streams(o, ic);
775 /* dump the file content */
776 av_dump_format(ic, nb_input_files, filename, 0);
778 GROW_ARRAY(input_files, nb_input_files);
779 f = av_mallocz(sizeof(*f));
782 input_files[nb_input_files - 1] = f;
785 f->ist_index = nb_input_streams - ic->nb_streams;
786 f->start_time = o->start_time;
787 f->recording_time = o->recording_time;
788 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
789 f->nb_streams = ic->nb_streams;
790 f->rate_emu = o->rate_emu;
791 f->accurate_seek = o->accurate_seek;
794 f->time_base = (AVRational){ 1, 1 };
796 /* check if all codec options have been used */
797 unused_opts = strip_specifiers(o->g->codec_opts);
798 for (i = f->ist_index; i < nb_input_streams; i++) {
800 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
801 AV_DICT_IGNORE_SUFFIX)))
802 av_dict_set(&unused_opts, e->key, NULL, 0);
806 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
807 const AVClass *class = avcodec_get_class();
808 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
809 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
812 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
813 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
814 "input file #%d (%s) is not a decoding option.\n", e->key,
815 option->help ? option->help : "", nb_input_files - 1,
820 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
821 "input file #%d (%s) has not been used for any stream. The most "
822 "likely reason is either wrong type (e.g. a video option with "
823 "no video streams) or that it is a private option of some decoder "
824 "which was not actually used for any stream.\n", e->key,
825 option->help ? option->help : "", nb_input_files - 1, filename);
827 av_dict_free(&unused_opts);
829 for (i = 0; i < o->nb_dump_attachment; i++) {
832 for (j = 0; j < ic->nb_streams; j++) {
833 AVStream *st = ic->streams[j];
835 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
836 dump_attachment(st, o->dump_attachment[i].u.str);
840 for (i = 0; i < orig_nb_streams; i++)
841 av_dict_free(&opts[i]);
847 static uint8_t *get_line(AVIOContext *s)
853 if (avio_open_dyn_buf(&line) < 0) {
854 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
858 while ((c = avio_r8(s)) && c != '\n')
861 avio_close_dyn_buf(line, &buf);
866 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
870 const char *base[3] = { getenv("AVCONV_DATADIR"),
875 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
879 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
880 i != 1 ? "" : "/.avconv", codec_name, preset_name);
881 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
884 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
885 i != 1 ? "" : "/.avconv", preset_name);
886 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
892 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
894 char *codec_name = NULL;
896 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
898 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
899 NULL, ost->st->codecpar->codec_type);
900 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
901 } else if (!strcmp(codec_name, "copy"))
902 ost->stream_copy = 1;
904 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
905 ost->st->codecpar->codec_id = ost->enc->id;
909 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
912 AVStream *st = avformat_new_stream(oc, NULL);
913 int idx = oc->nb_streams - 1, ret = 0;
914 char *bsf = NULL, *next, *codec_tag = NULL;
915 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
919 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
923 if (oc->nb_streams - 1 < o->nb_streamid_map)
924 st->id = o->streamid_map[oc->nb_streams - 1];
926 GROW_ARRAY(output_streams, nb_output_streams);
927 if (!(ost = av_mallocz(sizeof(*ost))))
929 output_streams[nb_output_streams - 1] = ost;
931 ost->file_index = nb_output_files - 1;
934 st->codecpar->codec_type = type;
935 choose_encoder(o, oc, ost);
937 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
939 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
942 ost->enc_ctx->codec_type = type;
945 AVIOContext *s = NULL;
946 char *buf = NULL, *arg = NULL, *preset = NULL;
948 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
950 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
951 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
954 if (!buf[0] || buf[0] == '#') {
958 if (!(arg = strchr(buf, '='))) {
959 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
963 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
965 } while (!s->eof_reached);
969 av_log(NULL, AV_LOG_FATAL,
970 "Preset %s specified for stream %d:%d, but could not be opened.\n",
971 preset, ost->file_index, ost->index);
975 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
978 ost->max_frames = INT64_MAX;
979 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
981 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
983 if (next = strchr(bsf, ','))
985 if (!(bsfc = av_bitstream_filter_init(bsf))) {
986 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
990 bsfc_prev->next = bsfc;
992 ost->bitstream_filters = bsfc;
998 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1000 uint32_t tag = strtol(codec_tag, &next, 0);
1002 tag = AV_RL32(codec_tag);
1003 ost->enc_ctx->codec_tag = tag;
1006 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1008 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1009 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1012 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1013 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1015 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1017 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1019 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1020 ost->last_mux_dts = AV_NOPTS_VALUE;
1025 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1028 const char *p = str;
1035 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1042 /* read file contents into a string */
1043 static uint8_t *read_file(const char *filename)
1045 AVIOContext *pb = NULL;
1046 AVIOContext *dyn_buf = NULL;
1047 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1048 uint8_t buf[1024], *str;
1051 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1055 ret = avio_open_dyn_buf(&dyn_buf);
1060 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1061 avio_write(dyn_buf, buf, ret);
1062 avio_w8(dyn_buf, 0);
1065 ret = avio_close_dyn_buf(dyn_buf, &str);
1071 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1074 AVStream *st = ost->st;
1075 char *filter = NULL, *filter_script = NULL;
1077 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1078 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1080 if (filter_script && filter) {
1081 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1082 "output stream #%d:%d.\n", nb_output_files, st->index);
1087 return read_file(filter_script);
1089 return av_strdup(filter);
1091 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1095 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1099 AVCodecContext *video_enc;
1100 char *frame_aspect_ratio = NULL;
1102 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1104 video_enc = ost->enc_ctx;
1106 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1107 if (frame_aspect_ratio)
1108 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1110 if (!ost->stream_copy) {
1111 const char *p = NULL;
1112 char *frame_rate = NULL, *frame_size = NULL;
1113 char *frame_pix_fmt = NULL;
1114 char *intra_matrix = NULL, *inter_matrix = NULL;
1118 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1119 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1120 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1124 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1125 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1126 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1130 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1131 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1132 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1135 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1137 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1139 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1140 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1143 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1145 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1147 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1148 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1151 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1154 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1155 for (i = 0; p; i++) {
1157 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1159 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1162 video_enc->rc_override =
1163 av_realloc(video_enc->rc_override,
1164 sizeof(RcOverride) * (i + 1));
1165 if (!video_enc->rc_override) {
1166 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1169 video_enc->rc_override[i].start_frame = start;
1170 video_enc->rc_override[i].end_frame = end;
1172 video_enc->rc_override[i].qscale = q;
1173 video_enc->rc_override[i].quality_factor = 1.0;
1176 video_enc->rc_override[i].qscale = 0;
1177 video_enc->rc_override[i].quality_factor = -q/100.0;
1182 video_enc->rc_override_count = i;
1183 video_enc->intra_dc_precision = intra_dc_precision - 8;
1186 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1189 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1191 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1195 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1196 if (ost->logfile_prefix &&
1197 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1201 char logfilename[1024];
1204 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1205 ost->logfile_prefix ? ost->logfile_prefix :
1206 DEFAULT_PASS_LOGFILENAME_PREFIX,
1208 if (!strcmp(ost->enc->name, "libx264")) {
1209 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1211 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1212 f = fopen(logfilename, "wb");
1214 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1215 logfilename, strerror(errno));
1220 char *logbuffer = read_file(logfilename);
1223 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1227 video_enc->stats_in = logbuffer;
1232 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1233 if (ost->forced_keyframes)
1234 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1236 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1238 ost->top_field_first = -1;
1239 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1242 ost->avfilter = get_ost_filters(o, oc, ost);
1246 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1252 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1256 AVCodecContext *audio_enc;
1258 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1261 audio_enc = ost->enc_ctx;
1262 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1264 if (!ost->stream_copy) {
1265 char *sample_fmt = NULL;
1267 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1269 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1271 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1272 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1276 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1278 ost->avfilter = get_ost_filters(o, oc, ost);
1286 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1290 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1291 if (!ost->stream_copy) {
1292 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1299 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1301 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1302 ost->stream_copy = 1;
1307 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1310 AVCodecContext *subtitle_enc;
1312 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1313 subtitle_enc = ost->enc_ctx;
1315 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1320 /* arg format is "output-stream-index:streamid-value". */
1321 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1323 OptionsContext *o = optctx;
1328 av_strlcpy(idx_str, arg, sizeof(idx_str));
1329 p = strchr(idx_str, ':');
1331 av_log(NULL, AV_LOG_FATAL,
1332 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1337 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1338 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1339 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1343 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1345 AVFormatContext *is = ifile->ctx;
1346 AVFormatContext *os = ofile->ctx;
1350 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1352 return AVERROR(ENOMEM);
1355 for (i = 0; i < is->nb_chapters; i++) {
1356 AVChapter *in_ch = is->chapters[i], *out_ch;
1357 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1358 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1359 AV_TIME_BASE_Q, in_ch->time_base);
1360 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1361 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1364 if (in_ch->end < ts_off)
1366 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1369 out_ch = av_mallocz(sizeof(AVChapter));
1371 return AVERROR(ENOMEM);
1373 out_ch->id = in_ch->id;
1374 out_ch->time_base = in_ch->time_base;
1375 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1376 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1379 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1381 os->chapters[os->nb_chapters++] = out_ch;
1386 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1387 AVFormatContext *oc)
1391 switch (ofilter->type) {
1392 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1393 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1395 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1400 ost->source_index = -1;
1401 ost->filter = ofilter;
1405 if (ost->stream_copy) {
1406 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1407 "which is fed from a complex filtergraph. Filtering and streamcopy "
1408 "cannot be used together.\n", ost->file_index, ost->index);
1412 avfilter_inout_free(&ofilter->out_tmp);
1415 static int init_complex_filters(void)
1419 for (i = 0; i < nb_filtergraphs; i++) {
1420 ret = init_complex_filtergraph(filtergraphs[i]);
1427 static int configure_complex_filters(void)
1431 for (i = 0; i < nb_filtergraphs; i++)
1432 if (!filtergraphs[i]->graph &&
1433 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1438 static int open_output_file(OptionsContext *o, const char *filename)
1440 AVFormatContext *oc;
1442 AVOutputFormat *file_oformat;
1446 AVDictionary *unused_opts = NULL;
1447 AVDictionaryEntry *e = NULL;
1449 GROW_ARRAY(output_files, nb_output_files);
1450 of = av_mallocz(sizeof(*of));
1453 output_files[nb_output_files - 1] = of;
1455 of->ost_index = nb_output_streams;
1456 of->recording_time = o->recording_time;
1457 of->start_time = o->start_time;
1458 of->limit_filesize = o->limit_filesize;
1459 of->shortest = o->shortest;
1460 av_dict_copy(&of->opts, o->g->format_opts, 0);
1462 if (!strcmp(filename, "-"))
1465 oc = avformat_alloc_context();
1467 print_error(filename, AVERROR(ENOMEM));
1471 if (o->recording_time != INT64_MAX)
1472 oc->duration = o->recording_time;
1475 file_oformat = av_guess_format(o->format, NULL, NULL);
1476 if (!file_oformat) {
1477 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1481 file_oformat = av_guess_format(NULL, filename, NULL);
1482 if (!file_oformat) {
1483 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1489 oc->oformat = file_oformat;
1490 oc->interrupt_callback = int_cb;
1491 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1493 /* create streams for all unlabeled output pads */
1494 for (i = 0; i < nb_filtergraphs; i++) {
1495 FilterGraph *fg = filtergraphs[i];
1496 for (j = 0; j < fg->nb_outputs; j++) {
1497 OutputFilter *ofilter = fg->outputs[j];
1499 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1502 switch (ofilter->type) {
1503 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1504 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1505 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1507 init_output_filter(ofilter, o, oc);
1511 if (!o->nb_stream_maps) {
1512 /* pick the "best" stream of each type */
1513 #define NEW_STREAM(type, index)\
1515 ost = new_ ## type ## _stream(o, oc);\
1516 ost->source_index = index;\
1517 ost->sync_ist = input_streams[index];\
1518 input_streams[index]->discard = 0;\
1519 input_streams[index]->st->discard = AVDISCARD_NONE;\
1522 /* video: highest resolution */
1523 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1524 int area = 0, idx = -1;
1525 for (i = 0; i < nb_input_streams; i++) {
1526 ist = input_streams[i];
1527 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1528 ist->st->codecpar->width * ist->st->codecpar->height > area) {
1529 area = ist->st->codecpar->width * ist->st->codecpar->height;
1533 NEW_STREAM(video, idx);
1536 /* audio: most channels */
1537 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1538 int channels = 0, idx = -1;
1539 for (i = 0; i < nb_input_streams; i++) {
1540 ist = input_streams[i];
1541 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1542 ist->st->codecpar->channels > channels) {
1543 channels = ist->st->codecpar->channels;
1547 NEW_STREAM(audio, idx);
1550 /* subtitles: pick first */
1551 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1552 for (i = 0; i < nb_input_streams; i++)
1553 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1554 NEW_STREAM(subtitle, i);
1558 /* do something with data? */
1560 for (i = 0; i < o->nb_stream_maps; i++) {
1561 StreamMap *map = &o->stream_maps[i];
1566 if (map->linklabel) {
1568 OutputFilter *ofilter = NULL;
1571 for (j = 0; j < nb_filtergraphs; j++) {
1572 fg = filtergraphs[j];
1573 for (k = 0; k < fg->nb_outputs; k++) {
1574 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1575 if (out && !strcmp(out->name, map->linklabel)) {
1576 ofilter = fg->outputs[k];
1583 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1584 "in any defined filter graph.\n", map->linklabel);
1587 init_output_filter(ofilter, o, oc);
1589 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1590 switch (ist->st->codecpar->codec_type) {
1591 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1592 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1593 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1594 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1595 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1597 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1598 map->file_index, map->stream_index);
1602 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1603 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1604 map->sync_stream_index];
1606 ist->st->discard = AVDISCARD_NONE;
1611 /* handle attached files */
1612 for (i = 0; i < o->nb_attachments; i++) {
1614 uint8_t *attachment;
1618 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1619 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1623 if ((len = avio_size(pb)) <= 0) {
1624 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1628 if (!(attachment = av_malloc(len))) {
1629 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1633 avio_read(pb, attachment, len);
1635 ost = new_attachment_stream(o, oc);
1636 ost->stream_copy = 0;
1637 ost->source_index = -1;
1638 ost->attachment_filename = o->attachments[i];
1639 ost->st->codecpar->extradata = attachment;
1640 ost->st->codecpar->extradata_size = len;
1642 p = strrchr(o->attachments[i], '/');
1643 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1647 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1648 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1649 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1653 /* check if all codec options have been used */
1654 unused_opts = strip_specifiers(o->g->codec_opts);
1655 for (i = of->ost_index; i < nb_output_streams; i++) {
1657 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1658 AV_DICT_IGNORE_SUFFIX)))
1659 av_dict_set(&unused_opts, e->key, NULL, 0);
1663 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1664 const AVClass *class = avcodec_get_class();
1665 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1666 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1669 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1670 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1671 "output file #%d (%s) is not an encoding option.\n", e->key,
1672 option->help ? option->help : "", nb_output_files - 1,
1677 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1678 "output file #%d (%s) has not been used for any stream. The most "
1679 "likely reason is either wrong type (e.g. a video option with "
1680 "no video streams) or that it is a private option of some encoder "
1681 "which was not actually used for any stream.\n", e->key,
1682 option->help ? option->help : "", nb_output_files - 1, filename);
1684 av_dict_free(&unused_opts);
1686 /* set the encoding/decoding_needed flags */
1687 for (i = of->ost_index; i < nb_output_streams; i++) {
1688 OutputStream *ost = output_streams[i];
1690 ost->encoding_needed = !ost->stream_copy;
1691 if (ost->encoding_needed && ost->source_index >= 0) {
1692 InputStream *ist = input_streams[ost->source_index];
1693 ist->decoding_needed = 1;
1697 /* check filename in case of an image number is expected */
1698 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1699 if (!av_filename_number_test(oc->filename)) {
1700 print_error(oc->filename, AVERROR(EINVAL));
1705 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1706 /* test if it already exists to avoid losing precious files */
1707 assert_file_overwrite(filename);
1710 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1711 &oc->interrupt_callback,
1713 print_error(filename, err);
1718 if (o->mux_preload) {
1720 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1721 av_dict_set(&of->opts, "preload", buf, 0);
1723 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1724 oc->flags |= AVFMT_FLAG_NONBLOCK;
1727 for (i = 0; i < o->nb_metadata_map; i++) {
1729 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1731 if (in_file_index >= nb_input_files) {
1732 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1735 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1736 in_file_index >= 0 ?
1737 input_files[in_file_index]->ctx : NULL, o);
1741 if (o->chapters_input_file >= nb_input_files) {
1742 if (o->chapters_input_file == INT_MAX) {
1743 /* copy chapters from the first input file that has them*/
1744 o->chapters_input_file = -1;
1745 for (i = 0; i < nb_input_files; i++)
1746 if (input_files[i]->ctx->nb_chapters) {
1747 o->chapters_input_file = i;
1751 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1752 o->chapters_input_file);
1756 if (o->chapters_input_file >= 0)
1757 copy_chapters(input_files[o->chapters_input_file], of,
1758 !o->metadata_chapters_manual);
1760 /* copy global metadata by default */
1761 if (!o->metadata_global_manual && nb_input_files)
1762 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1763 AV_DICT_DONT_OVERWRITE);
1764 if (!o->metadata_streams_manual)
1765 for (i = of->ost_index; i < nb_output_streams; i++) {
1767 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1769 ist = input_streams[output_streams[i]->source_index];
1770 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1773 /* process manually set metadata */
1774 for (i = 0; i < o->nb_metadata; i++) {
1777 const char *stream_spec;
1778 int index = 0, j, ret;
1780 val = strchr(o->metadata[i].u.str, '=');
1782 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1783 o->metadata[i].u.str);
1788 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1790 for (j = 0; j < oc->nb_streams; j++) {
1791 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1792 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1803 if (index < 0 || index >= oc->nb_chapters) {
1804 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1807 m = &oc->chapters[index]->metadata;
1810 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1813 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1820 static int opt_target(void *optctx, const char *opt, const char *arg)
1822 OptionsContext *o = optctx;
1823 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1824 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1826 if (!strncmp(arg, "pal-", 4)) {
1829 } else if (!strncmp(arg, "ntsc-", 5)) {
1832 } else if (!strncmp(arg, "film-", 5)) {
1836 /* Try to determine PAL/NTSC by peeking in the input files */
1837 if (nb_input_files) {
1839 for (j = 0; j < nb_input_files; j++) {
1840 for (i = 0; i < input_files[j]->nb_streams; i++) {
1841 AVStream *st = input_files[j]->ctx->streams[i];
1842 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1844 fr = st->time_base.den * 1000 / st->time_base.num;
1848 } else if ((fr == 29970) || (fr == 23976)) {
1853 if (norm != UNKNOWN)
1857 if (norm != UNKNOWN)
1858 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1861 if (norm == UNKNOWN) {
1862 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1863 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1864 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1868 if (!strcmp(arg, "vcd")) {
1869 opt_video_codec(o, "c:v", "mpeg1video");
1870 opt_audio_codec(o, "c:a", "mp2");
1871 parse_option(o, "f", "vcd", options);
1873 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1874 parse_option(o, "r", frame_rates[norm], options);
1875 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1877 opt_default(NULL, "b", "1150000");
1878 opt_default(NULL, "maxrate", "1150000");
1879 opt_default(NULL, "minrate", "1150000");
1880 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1882 opt_default(NULL, "b:a", "224000");
1883 parse_option(o, "ar", "44100", options);
1884 parse_option(o, "ac", "2", options);
1886 opt_default(NULL, "packetsize", "2324");
1887 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1889 /* We have to offset the PTS, so that it is consistent with the SCR.
1890 SCR starts at 36000, but the first two packs contain only padding
1891 and the first pack from the other stream, respectively, may also have
1892 been written before.
1893 So the real data starts at SCR 36000+3*1200. */
1894 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1895 } else if (!strcmp(arg, "svcd")) {
1897 opt_video_codec(o, "c:v", "mpeg2video");
1898 opt_audio_codec(o, "c:a", "mp2");
1899 parse_option(o, "f", "svcd", options);
1901 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1902 parse_option(o, "r", frame_rates[norm], options);
1903 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1905 opt_default(NULL, "b", "2040000");
1906 opt_default(NULL, "maxrate", "2516000");
1907 opt_default(NULL, "minrate", "0"); // 1145000;
1908 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1909 opt_default(NULL, "scan_offset", "1");
1912 opt_default(NULL, "b:a", "224000");
1913 parse_option(o, "ar", "44100", options);
1915 opt_default(NULL, "packetsize", "2324");
1917 } else if (!strcmp(arg, "dvd")) {
1919 opt_video_codec(o, "c:v", "mpeg2video");
1920 opt_audio_codec(o, "c:a", "ac3");
1921 parse_option(o, "f", "dvd", options);
1923 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1924 parse_option(o, "r", frame_rates[norm], options);
1925 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1927 opt_default(NULL, "b", "6000000");
1928 opt_default(NULL, "maxrate", "9000000");
1929 opt_default(NULL, "minrate", "0"); // 1500000;
1930 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1932 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1933 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1935 opt_default(NULL, "b:a", "448000");
1936 parse_option(o, "ar", "48000", options);
1938 } else if (!strncmp(arg, "dv", 2)) {
1940 parse_option(o, "f", "dv", options);
1942 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1943 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1944 norm == PAL ? "yuv420p" : "yuv411p", options);
1945 parse_option(o, "r", frame_rates[norm], options);
1947 parse_option(o, "ar", "48000", options);
1948 parse_option(o, "ac", "2", options);
1951 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1952 return AVERROR(EINVAL);
1955 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1956 av_dict_copy(&o->g->format_opts, format_opts, 0);
1961 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1963 av_free (vstats_filename);
1964 vstats_filename = av_strdup (arg);
1968 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1971 time_t today2 = time(NULL);
1972 struct tm *today = localtime(&today2);
1974 if (!today) { // maybe tomorrow
1975 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1979 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1981 return opt_vstats_file(NULL, opt, filename);
1984 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1986 OptionsContext *o = optctx;
1987 return parse_option(o, "frames:v", arg, options);
1990 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1992 OptionsContext *o = optctx;
1993 return parse_option(o, "frames:a", arg, options);
1996 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1998 OptionsContext *o = optctx;
1999 return parse_option(o, "frames:d", arg, options);
2002 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2004 OptionsContext *o = optctx;
2005 return parse_option(o, "tag:v", arg, options);
2008 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2010 OptionsContext *o = optctx;
2011 return parse_option(o, "tag:a", arg, options);
2014 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2016 OptionsContext *o = optctx;
2017 return parse_option(o, "tag:s", arg, options);
2020 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2022 OptionsContext *o = optctx;
2023 return parse_option(o, "filter:v", arg, options);
2026 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2028 OptionsContext *o = optctx;
2029 return parse_option(o, "filter:a", arg, options);
2032 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2034 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2035 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2036 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2038 if (video_sync_method == VSYNC_AUTO)
2039 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2043 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2045 OptionsContext *o = optctx;
2046 char layout_str[32];
2049 int ret, channels, ac_str_size;
2052 layout = av_get_channel_layout(arg);
2054 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2055 return AVERROR(EINVAL);
2057 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2058 ret = opt_default(NULL, opt, layout_str);
2062 /* set 'ac' option based on channel layout */
2063 channels = av_get_channel_layout_nb_channels(layout);
2064 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2065 stream_str = strchr(opt, ':');
2066 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2067 ac_str = av_mallocz(ac_str_size);
2069 return AVERROR(ENOMEM);
2070 av_strlcpy(ac_str, "ac", 3);
2072 av_strlcat(ac_str, stream_str, ac_str_size);
2073 ret = parse_option(o, ac_str, layout_str, options);
2079 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2081 OptionsContext *o = optctx;
2082 return parse_option(o, "q:a", arg, options);
2085 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2087 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2088 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2089 return AVERROR(ENOMEM);
2090 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2091 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2092 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2093 return AVERROR(ENOMEM);
2097 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2099 uint8_t *graph_desc = read_file(arg);
2101 return AVERROR(EINVAL);
2103 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2104 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2105 return AVERROR(ENOMEM);
2106 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2107 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2111 void show_help_default(const char *opt, const char *arg)
2113 /* per-file options have at least one of those set */
2114 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2115 int show_advanced = 0, show_avoptions = 0;
2118 if (!strcmp(opt, "long"))
2120 else if (!strcmp(opt, "full"))
2121 show_advanced = show_avoptions = 1;
2123 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2128 printf("Getting help:\n"
2129 " -h -- print basic options\n"
2130 " -h long -- print more options\n"
2131 " -h full -- print all options (including all format and codec specific options, very long)\n"
2132 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2133 " See man %s for detailed description of the options.\n"
2134 "\n", program_name);
2136 show_help_options(options, "Print help / information / capabilities:",
2139 show_help_options(options, "Global options (affect whole program "
2140 "instead of just one file:",
2141 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2143 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2144 per_file | OPT_EXIT, 0);
2146 show_help_options(options, "Per-file main options:", 0,
2147 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2148 OPT_EXIT, per_file);
2150 show_help_options(options, "Advanced per-file options:",
2151 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2153 show_help_options(options, "Video options:",
2154 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2156 show_help_options(options, "Advanced Video options:",
2157 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2159 show_help_options(options, "Audio options:",
2160 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2162 show_help_options(options, "Advanced Audio options:",
2163 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2164 show_help_options(options, "Subtitle options:",
2165 OPT_SUBTITLE, 0, 0);
2168 if (show_avoptions) {
2169 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2170 show_help_children(avcodec_get_class(), flags);
2171 show_help_children(avformat_get_class(), flags);
2172 show_help_children(sws_get_class(), flags);
2173 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2177 void show_usage(void)
2179 printf("Hyper fast Audio and Video encoder\n");
2180 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2189 static const OptionGroupDef groups[] = {
2190 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2191 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2194 static int open_files(OptionGroupList *l, const char *inout,
2195 int (*open_file)(OptionsContext*, const char*))
2199 for (i = 0; i < l->nb_groups; i++) {
2200 OptionGroup *g = &l->groups[i];
2206 ret = parse_optgroup(&o, g);
2208 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2209 "%s.\n", inout, g->arg);
2213 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2214 ret = open_file(&o, g->arg);
2217 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2221 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2227 int avconv_parse_options(int argc, char **argv)
2229 OptionParseContext octx;
2233 memset(&octx, 0, sizeof(octx));
2235 /* split the commandline into an internal representation */
2236 ret = split_commandline(&octx, argc, argv, options, groups,
2237 FF_ARRAY_ELEMS(groups));
2239 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2243 /* apply global options */
2244 ret = parse_optgroup(NULL, &octx.global_opts);
2246 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2250 /* open input files */
2251 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2253 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2257 /* create the complex filtergraphs */
2258 ret = init_complex_filters();
2260 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2264 /* open output files */
2265 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2267 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2271 /* configure the complex filtergraphs */
2272 ret = configure_complex_filters();
2274 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2279 uninit_parse_context(&octx);
2281 av_strerror(ret, error, sizeof(error));
2282 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2287 #define OFFSET(x) offsetof(OptionsContext, x)
2288 const OptionDef options[] = {
2290 #include "cmdutils_common_opts.h"
2291 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2292 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2293 "force format", "fmt" },
2294 { "y", OPT_BOOL, { &file_overwrite },
2295 "overwrite output files" },
2296 { "n", OPT_BOOL, { &file_skip },
2297 "never overwrite output files" },
2298 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2299 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2300 "codec name", "codec" },
2301 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2302 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2303 "codec name", "codec" },
2304 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2305 OPT_OUTPUT, { .off = OFFSET(presets) },
2306 "preset name", "preset" },
2307 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2308 OPT_OUTPUT, { .func_arg = opt_map },
2309 "set input stream mapping",
2310 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2311 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2312 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2313 "set metadata information of outfile from infile",
2314 "outfile[,metadata]:infile[,metadata]" },
2315 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2316 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2317 "set chapters mapping", "input_file_index" },
2318 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2319 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2320 "record or transcode \"duration\" seconds of audio/video",
2322 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2323 "set the limit file size in bytes", "limit_size" },
2324 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2325 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2326 "set the start time offset", "time_off" },
2327 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2328 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2329 "enable/disable accurate seeking with -ss" },
2330 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2331 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2332 "set the input ts offset", "time_off" },
2333 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2334 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2335 "set the input ts scale", "scale" },
2336 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2337 "add metadata", "string=string" },
2338 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2339 OPT_OUTPUT, { .func_arg = opt_data_frames },
2340 "set the number of data frames to record", "number" },
2341 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2342 "add timings for benchmarking" },
2343 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2344 "set max runtime in seconds", "limit" },
2345 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2346 "dump each input packet" },
2347 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2348 "when dumping packets, also dump the payload" },
2349 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2350 OPT_INPUT, { .off = OFFSET(rate_emu) },
2351 "read input at native frame rate", "" },
2352 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2353 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2354 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2355 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2356 "video sync method", "" },
2357 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2358 "audio sync method", "" },
2359 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2360 "audio drift threshold", "threshold" },
2361 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2362 "copy timestamps" },
2363 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2364 "copy input stream time base when stream copying" },
2365 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2366 OPT_OUTPUT, { .off = OFFSET(shortest) },
2367 "finish encoding within shortest input" },
2368 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2369 "timestamp discontinuity delta threshold", "threshold" },
2370 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2371 "exit on error", "error" },
2372 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2373 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2374 "copy initial non-keyframes" },
2375 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2376 "set the number of frames to record", "number" },
2377 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2378 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2379 "force codec tag/fourcc", "fourcc/tag" },
2380 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2381 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2382 "use fixed quality scale (VBR)", "q" },
2383 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2384 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2385 "use fixed quality scale (VBR)", "q" },
2386 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2387 "set stream filterchain", "filter_list" },
2388 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2389 "read stream filtergraph description from a file", "filename" },
2390 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2391 "create a complex filtergraph", "graph_description" },
2392 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2393 "read complex filtergraph description from a file", "filename" },
2394 { "stats", OPT_BOOL, { &print_stats },
2395 "print progress report during encoding", },
2396 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2397 OPT_OUTPUT, { .func_arg = opt_attach },
2398 "add an attachment to the output file", "filename" },
2399 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2400 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2401 "extract an attachment into a file", "filename" },
2402 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2403 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2406 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2407 "set the number of video frames to record", "number" },
2408 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2409 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2410 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2411 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2412 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2413 "set frame size (WxH or abbreviation)", "size" },
2414 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2415 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2416 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2417 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2418 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2419 "set pixel format", "format" },
2420 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2422 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2423 "discard threshold", "n" },
2424 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2425 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2426 "rate control override for specific intervals", "override" },
2427 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2428 OPT_OUTPUT, { .func_arg = opt_video_codec },
2429 "force video codec ('copy' to copy stream)", "codec" },
2430 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2431 "select the pass number (1 or 2)", "n" },
2432 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2433 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2434 "select two pass log file name prefix", "prefix" },
2435 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2436 "dump video coding statistics to file" },
2437 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2438 "dump video coding statistics to file", "file" },
2439 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2440 "video filters", "filter list" },
2441 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2442 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2443 "specify intra matrix coeffs", "matrix" },
2444 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2445 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2446 "specify inter matrix coeffs", "matrix" },
2447 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2448 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2449 "top=1/bottom=0/auto=-1 field first", "" },
2450 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2451 "intra_dc_precision", "precision" },
2452 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2453 OPT_OUTPUT, { .func_arg = opt_video_tag },
2454 "force video tag/fourcc", "fourcc/tag" },
2455 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2456 "show QP histogram" },
2457 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2458 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2459 "force the selected framerate, disable the best supported framerate selection" },
2460 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2461 OPT_OUTPUT, { .func_arg = opt_streamid },
2462 "set the value of an outfile streamid", "streamIndex:value" },
2463 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2464 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2465 "force key frames at specified timestamps", "timestamps" },
2466 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2467 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2468 "use HW accelerated decoding", "hwaccel name" },
2469 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2470 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2471 "select a device for HW acceleration", "devicename" },
2472 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2473 "show available HW acceleration methods" },
2474 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2475 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2476 "automatically insert correct rotate filters" },
2479 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2480 "set the number of audio frames to record", "number" },
2481 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2482 "set audio quality (codec-specific)", "quality", },
2483 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2484 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2485 "set audio sampling rate (in Hz)", "rate" },
2486 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2487 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2488 "set number of audio channels", "channels" },
2489 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2491 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2492 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2493 "force audio codec ('copy' to copy stream)", "codec" },
2494 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2495 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2496 "force audio tag/fourcc", "fourcc/tag" },
2497 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2498 "change audio volume (256=normal)" , "volume" },
2499 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2500 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2501 "set sample format", "format" },
2502 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2503 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2504 "set channel layout", "layout" },
2505 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2506 "audio filters", "filter list" },
2508 /* subtitle options */
2509 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2510 "disable subtitle" },
2511 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2512 "force subtitle codec ('copy' to copy stream)", "codec" },
2513 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2514 , "force subtitle tag/fourcc", "fourcc/tag" },
2517 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2520 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2521 "set the maximum demux-decode delay", "seconds" },
2522 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2523 "set the initial demux-decode delay", "seconds" },
2525 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2526 "A comma-separated list of bitstream filters", "bitstream_filters" },
2528 /* data codec support */
2529 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2530 "force data codec ('copy' to copy stream)", "codec" },