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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 char *vstats_filename;
58 float audio_drift_threshold = 0.1;
59 float dts_delta_threshold = 10;
61 int audio_volume = 256;
62 int audio_sync_method = 0;
63 int video_sync_method = VSYNC_AUTO;
69 int exit_on_error = 0;
73 static int file_overwrite = 0;
74 static int file_skip = 0;
75 static int video_discard = 0;
76 static int intra_dc_precision = 8;
77 static int using_stdin = 0;
78 static int input_sync;
80 static void uninit_options(OptionsContext *o)
82 const OptionDef *po = options;
85 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
87 void *dst = (uint8_t*)o + po->u.off;
89 if (po->flags & OPT_SPEC) {
90 SpecifierOpt **so = dst;
91 int i, *count = (int*)(so + 1);
92 for (i = 0; i < *count; i++) {
93 av_freep(&(*so)[i].specifier);
94 if (po->flags & OPT_STRING)
95 av_freep(&(*so)[i].u.str);
99 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
104 for (i = 0; i < o->nb_stream_maps; i++)
105 av_freep(&o->stream_maps[i].linklabel);
106 av_freep(&o->stream_maps);
107 av_freep(&o->meta_data_maps);
108 av_freep(&o->streamid_map);
111 static void init_options(OptionsContext *o)
113 memset(o, 0, sizeof(*o));
115 o->mux_max_delay = 0.7;
116 o->recording_time = INT64_MAX;
117 o->limit_filesize = UINT64_MAX;
118 o->chapters_input_file = INT_MAX;
121 /* return a copy of the input with the stream specifiers removed from the keys */
122 static AVDictionary *strip_specifiers(AVDictionary *dict)
124 AVDictionaryEntry *e = NULL;
125 AVDictionary *ret = NULL;
127 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
128 char *p = strchr(e->key, ':');
132 av_dict_set(&ret, e->key, e->value, 0);
139 static double parse_frame_aspect_ratio(const char *arg)
146 p = strchr(arg, ':');
148 x = strtol(arg, &end, 10);
150 y = strtol(end + 1, &end, 10);
152 ar = (double)x / (double)y;
154 ar = strtod(arg, NULL);
157 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
163 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
165 OptionsContext *o = optctx;
166 return parse_option(o, "codec:a", arg, options);
169 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
171 OptionsContext *o = optctx;
172 return parse_option(o, "codec:v", arg, options);
175 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
177 OptionsContext *o = optctx;
178 return parse_option(o, "codec:s", arg, options);
181 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 return parse_option(o, "codec:d", arg, options);
187 static int opt_map(void *optctx, const char *opt, const char *arg)
189 OptionsContext *o = optctx;
191 int i, negative = 0, file_idx;
192 int sync_file_idx = -1, sync_stream_idx;
200 map = av_strdup(arg);
202 /* parse sync stream first, just pick first matching stream */
203 if (sync = strchr(map, ',')) {
205 sync_file_idx = strtol(sync + 1, &sync, 0);
206 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
207 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
212 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
213 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
214 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
218 if (i == input_files[sync_file_idx]->nb_streams) {
219 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
220 "match any streams.\n", arg);
227 /* this mapping refers to lavfi output */
228 const char *c = map + 1;
229 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
230 m = &o->stream_maps[o->nb_stream_maps - 1];
231 m->linklabel = av_get_token(&c, "]");
233 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
237 file_idx = strtol(map, &p, 0);
238 if (file_idx >= nb_input_files || file_idx < 0) {
239 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
243 /* disable some already defined maps */
244 for (i = 0; i < o->nb_stream_maps; i++) {
245 m = &o->stream_maps[i];
246 if (file_idx == m->file_index &&
247 check_stream_specifier(input_files[m->file_index]->ctx,
248 input_files[m->file_index]->ctx->streams[m->stream_index],
249 *p == ':' ? p + 1 : p) > 0)
253 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
254 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
255 *p == ':' ? p + 1 : p) <= 0)
257 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
258 m = &o->stream_maps[o->nb_stream_maps - 1];
260 m->file_index = file_idx;
263 if (sync_file_idx >= 0) {
264 m->sync_file_index = sync_file_idx;
265 m->sync_stream_index = sync_stream_idx;
267 m->sync_file_index = file_idx;
268 m->sync_stream_index = i;
274 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
282 static int opt_attach(void *optctx, const char *opt, const char *arg)
284 OptionsContext *o = optctx;
285 GROW_ARRAY(o->attachments, o->nb_attachments);
286 o->attachments[o->nb_attachments - 1] = arg;
291 * Parse a metadata specifier passed as 'arg' parameter.
292 * @param arg metadata string to parse
293 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
294 * @param index for type c/p, chapter/program index is written here
295 * @param stream_spec for type s, the stream specifier is written here
297 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
305 if (*(++arg) && *arg != ':') {
306 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
309 *stream_spec = *arg == ':' ? arg + 1 : "";
314 *index = strtol(++arg, NULL, 0);
317 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
324 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
326 AVDictionary **meta_in = NULL;
327 AVDictionary **meta_out;
329 char type_in, type_out;
330 const char *istream_spec = NULL, *ostream_spec = NULL;
331 int idx_in = 0, idx_out = 0;
333 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
334 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
336 if (type_in == 'g' || type_out == 'g')
337 o->metadata_global_manual = 1;
338 if (type_in == 's' || type_out == 's')
339 o->metadata_streams_manual = 1;
340 if (type_in == 'c' || type_out == 'c')
341 o->metadata_chapters_manual = 1;
343 /* ic is NULL when just disabling automatic mappings */
347 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
348 if ((index) < 0 || (index) >= (nb_elems)) {\
349 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
354 #define SET_DICT(type, meta, context, index)\
357 meta = &context->metadata;\
360 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
361 meta = &context->chapters[index]->metadata;\
364 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
365 meta = &context->programs[index]->metadata;\
368 break; /* handled separately below */ \
369 default: av_assert0(0);\
372 SET_DICT(type_in, meta_in, ic, idx_in);
373 SET_DICT(type_out, meta_out, oc, idx_out);
375 /* for input streams choose first matching stream */
376 if (type_in == 's') {
377 for (i = 0; i < ic->nb_streams; i++) {
378 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
379 meta_in = &ic->streams[i]->metadata;
385 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
390 if (type_out == 's') {
391 for (i = 0; i < oc->nb_streams; i++) {
392 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
393 meta_out = &oc->streams[i]->metadata;
394 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
399 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
404 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
406 const AVCodecDescriptor *desc;
407 const char *codec_string = encoder ? "encoder" : "decoder";
411 avcodec_find_encoder_by_name(name) :
412 avcodec_find_decoder_by_name(name);
414 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
415 codec = encoder ? avcodec_find_encoder(desc->id) :
416 avcodec_find_decoder(desc->id);
418 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
419 codec_string, codec->name, desc->name);
423 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
426 if (codec->type != type) {
427 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
433 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
435 char *codec_name = NULL;
437 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
439 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
440 st->codec->codec_id = codec->id;
443 return avcodec_find_decoder(st->codec->codec_id);
446 /* Add all the streams from the given input file to the global
447 * list of input streams. */
448 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
452 for (i = 0; i < ic->nb_streams; i++) {
453 AVStream *st = ic->streams[i];
454 AVCodecContext *dec = st->codec;
455 InputStream *ist = av_mallocz(sizeof(*ist));
456 char *framerate = NULL;
461 GROW_ARRAY(input_streams, nb_input_streams);
462 input_streams[nb_input_streams - 1] = ist;
465 ist->file_index = nb_input_files;
467 st->discard = AVDISCARD_ALL;
470 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
472 ist->dec = choose_decoder(o, ic, st);
473 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
475 switch (dec->codec_type) {
476 case AVMEDIA_TYPE_VIDEO:
477 ist->resample_height = dec->height;
478 ist->resample_width = dec->width;
479 ist->resample_pix_fmt = dec->pix_fmt;
481 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
482 if (framerate && av_parse_video_rate(&ist->framerate,
484 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
490 case AVMEDIA_TYPE_AUDIO:
491 guess_input_channel_layout(ist);
493 ist->resample_sample_fmt = dec->sample_fmt;
494 ist->resample_sample_rate = dec->sample_rate;
495 ist->resample_channels = dec->channels;
496 ist->resample_channel_layout = dec->channel_layout;
499 case AVMEDIA_TYPE_DATA:
500 case AVMEDIA_TYPE_SUBTITLE:
501 case AVMEDIA_TYPE_ATTACHMENT:
502 case AVMEDIA_TYPE_UNKNOWN:
510 static void assert_file_overwrite(const char *filename)
512 if (file_overwrite && file_skip) {
513 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
517 if (!file_overwrite &&
518 (strchr(filename, ':') == NULL || filename[1] == ':' ||
519 av_strstart(filename, "file:", NULL))) {
520 if (avio_check(filename, 0) == 0) {
521 if (!using_stdin && !file_skip) {
522 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
525 fprintf(stderr, "Not overwriting - exiting\n");
530 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
537 static void dump_attachment(AVStream *st, const char *filename)
540 AVIOContext *out = NULL;
541 AVDictionaryEntry *e;
543 if (!st->codec->extradata_size) {
544 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
545 nb_input_files - 1, st->index);
548 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
551 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
552 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
556 assert_file_overwrite(filename);
558 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
559 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
564 avio_write(out, st->codec->extradata, st->codec->extradata_size);
569 static int open_input_file(OptionsContext *o, const char *filename)
573 AVInputFormat *file_iformat = NULL;
578 AVDictionary *unused_opts = NULL;
579 AVDictionaryEntry *e = NULL;
580 int orig_nb_streams; // number of streams before avformat_find_stream_info
583 if (!(file_iformat = av_find_input_format(o->format))) {
584 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
589 if (!strcmp(filename, "-"))
592 using_stdin |= !strncmp(filename, "pipe:", 5) ||
593 !strcmp(filename, "/dev/stdin");
595 /* get default parameters from command line */
596 ic = avformat_alloc_context();
598 print_error(filename, AVERROR(ENOMEM));
601 if (o->nb_audio_sample_rate) {
602 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
603 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
605 if (o->nb_audio_channels) {
606 /* because we set audio_channels based on both the "ac" and
607 * "channel_layout" options, we need to check that the specified
608 * demuxer actually has the "channels" option before setting it */
609 if (file_iformat && file_iformat->priv_class &&
610 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
611 AV_OPT_SEARCH_FAKE_OBJ)) {
612 snprintf(buf, sizeof(buf), "%d",
613 o->audio_channels[o->nb_audio_channels - 1].u.i);
614 av_dict_set(&o->g->format_opts, "channels", buf, 0);
617 if (o->nb_frame_rates) {
618 /* set the format-level framerate option;
619 * this is important for video grabbers, e.g. x11 */
620 if (file_iformat && file_iformat->priv_class &&
621 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
622 AV_OPT_SEARCH_FAKE_OBJ)) {
623 av_dict_set(&o->g->format_opts, "framerate",
624 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
627 if (o->nb_frame_sizes) {
628 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
630 if (o->nb_frame_pix_fmts)
631 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
633 ic->flags |= AVFMT_FLAG_NONBLOCK;
634 ic->interrupt_callback = int_cb;
636 /* open the input file with generic libav function */
637 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
639 print_error(filename, err);
642 assert_avoptions(o->g->format_opts);
644 /* apply forced codec ids */
645 for (i = 0; i < ic->nb_streams; i++)
646 choose_decoder(o, ic, ic->streams[i]);
648 /* Set AVCodecContext options for avformat_find_stream_info */
649 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
650 orig_nb_streams = ic->nb_streams;
652 /* If not enough info to get the stream parameters, we decode the
653 first frames to get it. (used in mpeg case for example) */
654 ret = avformat_find_stream_info(ic, opts);
656 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
657 avformat_close_input(&ic);
661 timestamp = o->start_time;
662 /* add the stream start time */
663 if (ic->start_time != AV_NOPTS_VALUE)
664 timestamp += ic->start_time;
666 /* if seeking requested, we execute it */
667 if (o->start_time != 0) {
668 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
670 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
671 filename, (double)timestamp / AV_TIME_BASE);
675 /* update the current parameters so that they match the one of the input stream */
676 add_input_streams(o, ic);
678 /* dump the file content */
679 av_dump_format(ic, nb_input_files, filename, 0);
681 GROW_ARRAY(input_files, nb_input_files);
682 f = av_mallocz(sizeof(*f));
685 input_files[nb_input_files - 1] = f;
688 f->ist_index = nb_input_streams - ic->nb_streams;
689 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
690 f->nb_streams = ic->nb_streams;
691 f->rate_emu = o->rate_emu;
693 /* check if all codec options have been used */
694 unused_opts = strip_specifiers(o->g->codec_opts);
695 for (i = f->ist_index; i < nb_input_streams; i++) {
697 while ((e = av_dict_get(input_streams[i]->opts, "", e,
698 AV_DICT_IGNORE_SUFFIX)))
699 av_dict_set(&unused_opts, e->key, NULL, 0);
703 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
704 const AVClass *class = avcodec_get_class();
705 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
706 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
709 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
710 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
711 "input file #%d (%s) is not a decoding option.\n", e->key,
712 option->help ? option->help : "", nb_input_files - 1,
717 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
718 "input file #%d (%s) has not been used for any stream. The most "
719 "likely reason is either wrong type (e.g. a video option with "
720 "no video streams) or that it is a private option of some decoder "
721 "which was not actually used for any stream.\n", e->key,
722 option->help ? option->help : "", nb_input_files - 1, filename);
724 av_dict_free(&unused_opts);
726 for (i = 0; i < o->nb_dump_attachment; i++) {
729 for (j = 0; j < ic->nb_streams; j++) {
730 AVStream *st = ic->streams[j];
732 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
733 dump_attachment(st, o->dump_attachment[i].u.str);
737 for (i = 0; i < orig_nb_streams; i++)
738 av_dict_free(&opts[i]);
744 static uint8_t *get_line(AVIOContext *s)
750 if (avio_open_dyn_buf(&line) < 0) {
751 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
755 while ((c = avio_r8(s)) && c != '\n')
758 avio_close_dyn_buf(line, &buf);
763 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
767 const char *base[3] = { getenv("AVCONV_DATADIR"),
772 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
776 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
777 i != 1 ? "" : "/.avconv", codec_name, preset_name);
778 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
781 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
782 i != 1 ? "" : "/.avconv", preset_name);
783 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
789 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
791 char *codec_name = NULL;
793 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
795 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
796 NULL, ost->st->codec->codec_type);
797 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
798 } else if (!strcmp(codec_name, "copy"))
799 ost->stream_copy = 1;
801 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
802 ost->st->codec->codec_id = ost->enc->id;
806 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
809 AVStream *st = avformat_new_stream(oc, NULL);
810 int idx = oc->nb_streams - 1, ret = 0;
811 char *bsf = NULL, *next, *codec_tag = NULL;
812 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
816 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
820 if (oc->nb_streams - 1 < o->nb_streamid_map)
821 st->id = o->streamid_map[oc->nb_streams - 1];
823 GROW_ARRAY(output_streams, nb_output_streams);
824 if (!(ost = av_mallocz(sizeof(*ost))))
826 output_streams[nb_output_streams - 1] = ost;
828 ost->file_index = nb_output_files - 1;
831 st->codec->codec_type = type;
832 choose_encoder(o, oc, ost);
834 AVIOContext *s = NULL;
835 char *buf = NULL, *arg = NULL, *preset = NULL;
837 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
839 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
840 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
843 if (!buf[0] || buf[0] == '#') {
847 if (!(arg = strchr(buf, '='))) {
848 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
852 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
854 } while (!s->eof_reached);
858 av_log(NULL, AV_LOG_FATAL,
859 "Preset %s specified for stream %d:%d, but could not be opened.\n",
860 preset, ost->file_index, ost->index);
864 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
867 avcodec_get_context_defaults3(st->codec, ost->enc);
868 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
870 ost->max_frames = INT64_MAX;
871 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
873 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
875 if (next = strchr(bsf, ','))
877 if (!(bsfc = av_bitstream_filter_init(bsf))) {
878 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
882 bsfc_prev->next = bsfc;
884 ost->bitstream_filters = bsfc;
890 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
892 uint32_t tag = strtol(codec_tag, &next, 0);
894 tag = AV_RL32(codec_tag);
895 st->codec->codec_tag = tag;
898 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
900 st->codec->flags |= CODEC_FLAG_QSCALE;
901 st->codec->global_quality = FF_QP2LAMBDA * qscale;
904 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
905 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
907 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
909 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
911 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
912 ost->last_mux_dts = AV_NOPTS_VALUE;
917 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
927 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
934 /* read file contents into a string */
935 static uint8_t *read_file(const char *filename)
937 AVIOContext *pb = NULL;
938 AVIOContext *dyn_buf = NULL;
939 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
940 uint8_t buf[1024], *str;
943 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
947 ret = avio_open_dyn_buf(&dyn_buf);
952 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
953 avio_write(dyn_buf, buf, ret);
957 ret = avio_close_dyn_buf(dyn_buf, &str);
963 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
966 AVStream *st = ost->st;
967 char *filter = NULL, *filter_script = NULL;
969 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
970 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
972 if (filter_script && filter) {
973 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
974 "output stream #%d:%d.\n", nb_output_files, st->index);
979 return read_file(filter_script);
981 return av_strdup(filter);
983 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
987 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
991 AVCodecContext *video_enc;
992 char *frame_aspect_ratio = NULL;
994 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
996 video_enc = st->codec;
998 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
999 if (frame_aspect_ratio)
1000 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1002 if (!ost->stream_copy) {
1003 const char *p = NULL;
1004 char *frame_rate = NULL, *frame_size = NULL;
1005 char *frame_pix_fmt = NULL;
1006 char *intra_matrix = NULL, *inter_matrix = NULL;
1010 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1011 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1012 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1016 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1017 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1018 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1022 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1023 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1024 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1027 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1029 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1031 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1032 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1035 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1037 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1039 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1040 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1043 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1046 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1047 for (i = 0; p; i++) {
1049 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1051 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1054 video_enc->rc_override =
1055 av_realloc(video_enc->rc_override,
1056 sizeof(RcOverride) * (i + 1));
1057 video_enc->rc_override[i].start_frame = start;
1058 video_enc->rc_override[i].end_frame = end;
1060 video_enc->rc_override[i].qscale = q;
1061 video_enc->rc_override[i].quality_factor = 1.0;
1064 video_enc->rc_override[i].qscale = 0;
1065 video_enc->rc_override[i].quality_factor = -q/100.0;
1070 video_enc->rc_override_count = i;
1071 video_enc->intra_dc_precision = intra_dc_precision - 8;
1074 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1077 video_enc->flags |= CODEC_FLAG_PASS1;
1079 video_enc->flags |= CODEC_FLAG_PASS2;
1083 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1084 if (ost->logfile_prefix &&
1085 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1088 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1089 if (ost->forced_keyframes)
1090 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1092 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1094 ost->top_field_first = -1;
1095 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1098 ost->avfilter = get_ost_filters(o, oc, ost);
1102 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1108 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1112 AVCodecContext *audio_enc;
1114 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1117 audio_enc = st->codec;
1118 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1120 if (!ost->stream_copy) {
1121 char *sample_fmt = NULL;
1123 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1125 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1127 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1128 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1132 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1134 ost->avfilter = get_ost_filters(o, oc, ost);
1142 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1146 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1147 if (!ost->stream_copy) {
1148 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1155 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1157 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1158 ost->stream_copy = 1;
1163 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1167 AVCodecContext *subtitle_enc;
1169 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1171 subtitle_enc = st->codec;
1173 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1178 /* arg format is "output-stream-index:streamid-value". */
1179 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1181 OptionsContext *o = optctx;
1186 av_strlcpy(idx_str, arg, sizeof(idx_str));
1187 p = strchr(idx_str, ':');
1189 av_log(NULL, AV_LOG_FATAL,
1190 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1195 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1196 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1197 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1201 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1203 AVFormatContext *is = ifile->ctx;
1204 AVFormatContext *os = ofile->ctx;
1208 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1210 return AVERROR(ENOMEM);
1213 for (i = 0; i < is->nb_chapters; i++) {
1214 AVChapter *in_ch = is->chapters[i], *out_ch;
1215 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1216 AV_TIME_BASE_Q, in_ch->time_base);
1217 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1218 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1221 if (in_ch->end < ts_off)
1223 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1226 out_ch = av_mallocz(sizeof(AVChapter));
1228 return AVERROR(ENOMEM);
1230 out_ch->id = in_ch->id;
1231 out_ch->time_base = in_ch->time_base;
1232 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1233 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1236 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1238 os->chapters[os->nb_chapters++] = out_ch;
1243 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1244 AVFormatContext *oc)
1248 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1249 ofilter->out_tmp->pad_idx)) {
1250 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1251 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1253 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1258 ost->source_index = -1;
1259 ost->filter = ofilter;
1263 if (ost->stream_copy) {
1264 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1265 "which is fed from a complex filtergraph. Filtering and streamcopy "
1266 "cannot be used together.\n", ost->file_index, ost->index);
1270 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1271 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1274 avfilter_inout_free(&ofilter->out_tmp);
1277 static int configure_complex_filters(void)
1281 for (i = 0; i < nb_filtergraphs; i++)
1282 if (!filtergraphs[i]->graph &&
1283 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1288 static int open_output_file(OptionsContext *o, const char *filename)
1290 AVFormatContext *oc;
1292 AVOutputFormat *file_oformat;
1296 AVDictionary *unused_opts = NULL;
1297 AVDictionaryEntry *e = NULL;
1299 if (configure_complex_filters() < 0) {
1300 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1304 GROW_ARRAY(output_files, nb_output_files);
1305 of = av_mallocz(sizeof(*of));
1308 output_files[nb_output_files - 1] = of;
1310 of->ost_index = nb_output_streams;
1311 of->recording_time = o->recording_time;
1312 of->start_time = o->start_time;
1313 of->limit_filesize = o->limit_filesize;
1314 of->shortest = o->shortest;
1315 av_dict_copy(&of->opts, o->g->format_opts, 0);
1317 if (!strcmp(filename, "-"))
1320 oc = avformat_alloc_context();
1322 print_error(filename, AVERROR(ENOMEM));
1326 if (o->recording_time != INT64_MAX)
1327 oc->duration = o->recording_time;
1330 file_oformat = av_guess_format(o->format, NULL, NULL);
1331 if (!file_oformat) {
1332 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1336 file_oformat = av_guess_format(NULL, filename, NULL);
1337 if (!file_oformat) {
1338 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1344 oc->oformat = file_oformat;
1345 oc->interrupt_callback = int_cb;
1346 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1348 /* create streams for all unlabeled output pads */
1349 for (i = 0; i < nb_filtergraphs; i++) {
1350 FilterGraph *fg = filtergraphs[i];
1351 for (j = 0; j < fg->nb_outputs; j++) {
1352 OutputFilter *ofilter = fg->outputs[j];
1354 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1357 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1358 ofilter->out_tmp->pad_idx)) {
1359 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1360 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1361 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1363 init_output_filter(ofilter, o, oc);
1367 if (!o->nb_stream_maps) {
1368 /* pick the "best" stream of each type */
1369 #define NEW_STREAM(type, index)\
1371 ost = new_ ## type ## _stream(o, oc);\
1372 ost->source_index = index;\
1373 ost->sync_ist = input_streams[index];\
1374 input_streams[index]->discard = 0;\
1375 input_streams[index]->st->discard = AVDISCARD_NONE;\
1378 /* video: highest resolution */
1379 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1380 int area = 0, idx = -1;
1381 for (i = 0; i < nb_input_streams; i++) {
1382 ist = input_streams[i];
1383 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1384 ist->st->codec->width * ist->st->codec->height > area) {
1385 area = ist->st->codec->width * ist->st->codec->height;
1389 NEW_STREAM(video, idx);
1392 /* audio: most channels */
1393 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1394 int channels = 0, idx = -1;
1395 for (i = 0; i < nb_input_streams; i++) {
1396 ist = input_streams[i];
1397 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1398 ist->st->codec->channels > channels) {
1399 channels = ist->st->codec->channels;
1403 NEW_STREAM(audio, idx);
1406 /* subtitles: pick first */
1407 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1408 for (i = 0; i < nb_input_streams; i++)
1409 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1410 NEW_STREAM(subtitle, i);
1414 /* do something with data? */
1416 for (i = 0; i < o->nb_stream_maps; i++) {
1417 StreamMap *map = &o->stream_maps[i];
1422 if (map->linklabel) {
1424 OutputFilter *ofilter = NULL;
1427 for (j = 0; j < nb_filtergraphs; j++) {
1428 fg = filtergraphs[j];
1429 for (k = 0; k < fg->nb_outputs; k++) {
1430 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1431 if (out && !strcmp(out->name, map->linklabel)) {
1432 ofilter = fg->outputs[k];
1439 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1440 "in any defined filter graph.\n", map->linklabel);
1443 init_output_filter(ofilter, o, oc);
1445 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1446 switch (ist->st->codec->codec_type) {
1447 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1448 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1449 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1450 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1451 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1453 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1454 map->file_index, map->stream_index);
1458 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1459 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1460 map->sync_stream_index];
1462 ist->st->discard = AVDISCARD_NONE;
1467 /* handle attached files */
1468 for (i = 0; i < o->nb_attachments; i++) {
1470 uint8_t *attachment;
1474 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1475 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1479 if ((len = avio_size(pb)) <= 0) {
1480 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1484 if (!(attachment = av_malloc(len))) {
1485 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1489 avio_read(pb, attachment, len);
1491 ost = new_attachment_stream(o, oc);
1492 ost->stream_copy = 0;
1493 ost->source_index = -1;
1494 ost->attachment_filename = o->attachments[i];
1495 ost->st->codec->extradata = attachment;
1496 ost->st->codec->extradata_size = len;
1498 p = strrchr(o->attachments[i], '/');
1499 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1503 /* check if all codec options have been used */
1504 unused_opts = strip_specifiers(o->g->codec_opts);
1505 for (i = of->ost_index; i < nb_output_streams; i++) {
1507 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1508 AV_DICT_IGNORE_SUFFIX)))
1509 av_dict_set(&unused_opts, e->key, NULL, 0);
1513 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1514 const AVClass *class = avcodec_get_class();
1515 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1516 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1519 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1520 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1521 "output file #%d (%s) is not an encoding option.\n", e->key,
1522 option->help ? option->help : "", nb_output_files - 1,
1527 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1528 "output file #%d (%s) has not been used for any stream. The most "
1529 "likely reason is either wrong type (e.g. a video option with "
1530 "no video streams) or that it is a private option of some encoder "
1531 "which was not actually used for any stream.\n", e->key,
1532 option->help ? option->help : "", nb_output_files - 1, filename);
1534 av_dict_free(&unused_opts);
1536 /* check filename in case of an image number is expected */
1537 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1538 if (!av_filename_number_test(oc->filename)) {
1539 print_error(oc->filename, AVERROR(EINVAL));
1544 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1545 /* test if it already exists to avoid losing precious files */
1546 assert_file_overwrite(filename);
1549 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1550 &oc->interrupt_callback,
1552 print_error(filename, err);
1557 if (o->mux_preload) {
1559 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1560 av_dict_set(&of->opts, "preload", buf, 0);
1562 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1563 oc->flags |= AVFMT_FLAG_NONBLOCK;
1566 for (i = 0; i < o->nb_metadata_map; i++) {
1568 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1570 if (in_file_index >= nb_input_files) {
1571 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1574 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1575 in_file_index >= 0 ?
1576 input_files[in_file_index]->ctx : NULL, o);
1580 if (o->chapters_input_file >= nb_input_files) {
1581 if (o->chapters_input_file == INT_MAX) {
1582 /* copy chapters from the first input file that has them*/
1583 o->chapters_input_file = -1;
1584 for (i = 0; i < nb_input_files; i++)
1585 if (input_files[i]->ctx->nb_chapters) {
1586 o->chapters_input_file = i;
1590 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1591 o->chapters_input_file);
1595 if (o->chapters_input_file >= 0)
1596 copy_chapters(input_files[o->chapters_input_file], of,
1597 !o->metadata_chapters_manual);
1599 /* copy global metadata by default */
1600 if (!o->metadata_global_manual && nb_input_files)
1601 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1602 AV_DICT_DONT_OVERWRITE);
1603 if (!o->metadata_streams_manual)
1604 for (i = of->ost_index; i < nb_output_streams; i++) {
1606 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1608 ist = input_streams[output_streams[i]->source_index];
1609 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1612 /* process manually set metadata */
1613 for (i = 0; i < o->nb_metadata; i++) {
1616 const char *stream_spec;
1617 int index = 0, j, ret;
1619 val = strchr(o->metadata[i].u.str, '=');
1621 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1622 o->metadata[i].u.str);
1627 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1629 for (j = 0; j < oc->nb_streams; j++) {
1630 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1631 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1642 if (index < 0 || index >= oc->nb_chapters) {
1643 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1646 m = &oc->chapters[index]->metadata;
1649 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1652 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1659 static int opt_target(void *optctx, const char *opt, const char *arg)
1661 OptionsContext *o = optctx;
1662 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1663 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1665 if (!strncmp(arg, "pal-", 4)) {
1668 } else if (!strncmp(arg, "ntsc-", 5)) {
1671 } else if (!strncmp(arg, "film-", 5)) {
1675 /* Try to determine PAL/NTSC by peeking in the input files */
1676 if (nb_input_files) {
1678 for (j = 0; j < nb_input_files; j++) {
1679 for (i = 0; i < input_files[j]->nb_streams; i++) {
1680 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1681 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1683 fr = c->time_base.den * 1000 / c->time_base.num;
1687 } else if ((fr == 29970) || (fr == 23976)) {
1692 if (norm != UNKNOWN)
1696 if (norm != UNKNOWN)
1697 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1700 if (norm == UNKNOWN) {
1701 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1702 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1703 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1707 if (!strcmp(arg, "vcd")) {
1708 opt_video_codec(o, "c:v", "mpeg1video");
1709 opt_audio_codec(o, "c:a", "mp2");
1710 parse_option(o, "f", "vcd", options);
1712 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1713 parse_option(o, "r", frame_rates[norm], options);
1714 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1716 opt_default(NULL, "b", "1150000");
1717 opt_default(NULL, "maxrate", "1150000");
1718 opt_default(NULL, "minrate", "1150000");
1719 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1721 opt_default(NULL, "b:a", "224000");
1722 parse_option(o, "ar", "44100", options);
1723 parse_option(o, "ac", "2", options);
1725 opt_default(NULL, "packetsize", "2324");
1726 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1728 /* We have to offset the PTS, so that it is consistent with the SCR.
1729 SCR starts at 36000, but the first two packs contain only padding
1730 and the first pack from the other stream, respectively, may also have
1731 been written before.
1732 So the real data starts at SCR 36000+3*1200. */
1733 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1734 } else if (!strcmp(arg, "svcd")) {
1736 opt_video_codec(o, "c:v", "mpeg2video");
1737 opt_audio_codec(o, "c:a", "mp2");
1738 parse_option(o, "f", "svcd", options);
1740 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1741 parse_option(o, "r", frame_rates[norm], options);
1742 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1744 opt_default(NULL, "b", "2040000");
1745 opt_default(NULL, "maxrate", "2516000");
1746 opt_default(NULL, "minrate", "0"); // 1145000;
1747 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1748 opt_default(NULL, "flags", "+scan_offset");
1751 opt_default(NULL, "b:a", "224000");
1752 parse_option(o, "ar", "44100", options);
1754 opt_default(NULL, "packetsize", "2324");
1756 } else if (!strcmp(arg, "dvd")) {
1758 opt_video_codec(o, "c:v", "mpeg2video");
1759 opt_audio_codec(o, "c:a", "ac3");
1760 parse_option(o, "f", "dvd", options);
1762 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1763 parse_option(o, "r", frame_rates[norm], options);
1764 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1766 opt_default(NULL, "b", "6000000");
1767 opt_default(NULL, "maxrate", "9000000");
1768 opt_default(NULL, "minrate", "0"); // 1500000;
1769 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1771 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1772 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1774 opt_default(NULL, "b:a", "448000");
1775 parse_option(o, "ar", "48000", options);
1777 } else if (!strncmp(arg, "dv", 2)) {
1779 parse_option(o, "f", "dv", options);
1781 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1782 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1783 norm == PAL ? "yuv420p" : "yuv411p", options);
1784 parse_option(o, "r", frame_rates[norm], options);
1786 parse_option(o, "ar", "48000", options);
1787 parse_option(o, "ac", "2", options);
1790 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1791 return AVERROR(EINVAL);
1796 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1798 av_free (vstats_filename);
1799 vstats_filename = av_strdup (arg);
1803 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1806 time_t today2 = time(NULL);
1807 struct tm *today = localtime(&today2);
1809 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1811 return opt_vstats_file(NULL, opt, filename);
1814 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1816 OptionsContext *o = optctx;
1817 return parse_option(o, "frames:v", arg, options);
1820 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1822 OptionsContext *o = optctx;
1823 return parse_option(o, "frames:a", arg, options);
1826 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1828 OptionsContext *o = optctx;
1829 return parse_option(o, "frames:d", arg, options);
1832 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1834 OptionsContext *o = optctx;
1835 return parse_option(o, "tag:v", arg, options);
1838 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1840 OptionsContext *o = optctx;
1841 return parse_option(o, "tag:a", arg, options);
1844 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1846 OptionsContext *o = optctx;
1847 return parse_option(o, "tag:s", arg, options);
1850 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1852 OptionsContext *o = optctx;
1853 return parse_option(o, "filter:v", arg, options);
1856 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1858 OptionsContext *o = optctx;
1859 return parse_option(o, "filter:a", arg, options);
1862 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1864 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1865 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1866 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1868 if (video_sync_method == VSYNC_AUTO)
1869 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1873 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1875 int flags = av_parse_cpu_flags(arg);
1880 av_set_cpu_flags_mask(flags);
1884 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1886 OptionsContext *o = optctx;
1887 char layout_str[32];
1890 int ret, channels, ac_str_size;
1893 layout = av_get_channel_layout(arg);
1895 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1896 return AVERROR(EINVAL);
1898 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1899 ret = opt_default(NULL, opt, layout_str);
1903 /* set 'ac' option based on channel layout */
1904 channels = av_get_channel_layout_nb_channels(layout);
1905 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1906 stream_str = strchr(opt, ':');
1907 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1908 ac_str = av_mallocz(ac_str_size);
1910 return AVERROR(ENOMEM);
1911 av_strlcpy(ac_str, "ac", 3);
1913 av_strlcat(ac_str, stream_str, ac_str_size);
1914 ret = parse_option(o, ac_str, layout_str, options);
1920 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1922 OptionsContext *o = optctx;
1923 return parse_option(o, "q:a", arg, options);
1926 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1928 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1929 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1930 return AVERROR(ENOMEM);
1931 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1932 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1933 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1934 return AVERROR(ENOMEM);
1938 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1940 uint8_t *graph_desc = read_file(arg);
1942 return AVERROR(EINVAL);
1944 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1945 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1946 return AVERROR(ENOMEM);
1947 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1948 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1952 void show_help_default(const char *opt, const char *arg)
1954 /* per-file options have at least one of those set */
1955 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1956 int show_advanced = 0, show_avoptions = 0;
1959 if (!strcmp(opt, "long"))
1961 else if (!strcmp(opt, "full"))
1962 show_advanced = show_avoptions = 1;
1964 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1969 printf("Getting help:\n"
1970 " -h -- print basic options\n"
1971 " -h long -- print more options\n"
1972 " -h full -- print all options (including all format and codec specific options, very long)\n"
1973 " See man %s for detailed description of the options.\n"
1974 "\n", program_name);
1976 show_help_options(options, "Print help / information / capabilities:",
1979 show_help_options(options, "Global options (affect whole program "
1980 "instead of just one file:",
1981 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1983 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1984 per_file | OPT_EXIT, 0);
1986 show_help_options(options, "Per-file main options:", 0,
1987 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1988 OPT_EXIT, per_file);
1990 show_help_options(options, "Advanced per-file options:",
1991 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1993 show_help_options(options, "Video options:",
1994 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1996 show_help_options(options, "Advanced Video options:",
1997 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1999 show_help_options(options, "Audio options:",
2000 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2002 show_help_options(options, "Advanced Audio options:",
2003 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2004 show_help_options(options, "Subtitle options:",
2005 OPT_SUBTITLE, 0, 0);
2008 if (show_avoptions) {
2009 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2010 show_help_children(avcodec_get_class(), flags);
2011 show_help_children(avformat_get_class(), flags);
2012 show_help_children(sws_get_class(), flags);
2013 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2017 void show_usage(void)
2019 printf("Hyper fast Audio and Video encoder\n");
2020 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2029 static const OptionGroupDef groups[] = {
2030 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2031 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2034 static int open_files(OptionGroupList *l, const char *inout,
2035 int (*open_file)(OptionsContext*, const char*))
2039 for (i = 0; i < l->nb_groups; i++) {
2040 OptionGroup *g = &l->groups[i];
2046 ret = parse_optgroup(&o, g);
2048 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2049 "%s.\n", inout, g->arg);
2053 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2054 ret = open_file(&o, g->arg);
2057 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2061 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2067 int avconv_parse_options(int argc, char **argv)
2069 OptionParseContext octx;
2073 memset(&octx, 0, sizeof(octx));
2075 /* split the commandline into an internal representation */
2076 ret = split_commandline(&octx, argc, argv, options, groups,
2077 FF_ARRAY_ELEMS(groups));
2079 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2083 /* apply global options */
2084 ret = parse_optgroup(NULL, &octx.global_opts);
2086 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2090 /* open input files */
2091 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2093 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2097 /* open output files */
2098 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2100 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2105 uninit_parse_context(&octx);
2107 av_strerror(ret, error, sizeof(error));
2108 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2113 #define OFFSET(x) offsetof(OptionsContext, x)
2114 const OptionDef options[] = {
2116 #include "cmdutils_common_opts.h"
2117 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2118 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2119 "force format", "fmt" },
2120 { "y", OPT_BOOL, { &file_overwrite },
2121 "overwrite output files" },
2122 { "n", OPT_BOOL, { &file_skip },
2123 "never overwrite output files" },
2124 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2125 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2126 "codec name", "codec" },
2127 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2128 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2129 "codec name", "codec" },
2130 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2131 OPT_OUTPUT, { .off = OFFSET(presets) },
2132 "preset name", "preset" },
2133 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2134 OPT_OUTPUT, { .func_arg = opt_map },
2135 "set input stream mapping",
2136 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2137 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2138 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2139 "set metadata information of outfile from infile",
2140 "outfile[,metadata]:infile[,metadata]" },
2141 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2142 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2143 "set chapters mapping", "input_file_index" },
2144 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2145 "record or transcode \"duration\" seconds of audio/video",
2147 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2148 "set the limit file size in bytes", "limit_size" },
2149 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2150 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2151 "set the start time offset", "time_off" },
2152 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2153 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2154 "set the input ts offset", "time_off" },
2155 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2156 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2157 "set the input ts scale", "scale" },
2158 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2159 "add metadata", "string=string" },
2160 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2161 OPT_OUTPUT, { .func_arg = opt_data_frames },
2162 "set the number of data frames to record", "number" },
2163 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2164 "add timings for benchmarking" },
2165 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2166 "set max runtime in seconds", "limit" },
2167 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2168 "dump each input packet" },
2169 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2170 "when dumping packets, also dump the payload" },
2171 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2172 OPT_INPUT, { .off = OFFSET(rate_emu) },
2173 "read input at native frame rate", "" },
2174 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2175 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2176 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2177 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2178 "video sync method", "" },
2179 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2180 "audio sync method", "" },
2181 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2182 "audio drift threshold", "threshold" },
2183 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2184 "copy timestamps" },
2185 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2186 "copy input stream time base when stream copying" },
2187 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2188 OPT_OUTPUT, { .off = OFFSET(shortest) },
2189 "finish encoding within shortest input" },
2190 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2191 "timestamp discontinuity delta threshold", "threshold" },
2192 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2193 "exit on error", "error" },
2194 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2195 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2196 "copy initial non-keyframes" },
2197 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2198 "set the number of frames to record", "number" },
2199 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2200 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2201 "force codec tag/fourcc", "fourcc/tag" },
2202 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2203 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2204 "use fixed quality scale (VBR)", "q" },
2205 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2206 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2207 "use fixed quality scale (VBR)", "q" },
2208 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2209 "set stream filterchain", "filter_list" },
2210 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2211 "read stream filtergraph description from a file", "filename" },
2212 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2213 "create a complex filtergraph", "graph_description" },
2214 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2215 "read complex filtergraph description from a file", "filename" },
2216 { "stats", OPT_BOOL, { &print_stats },
2217 "print progress report during encoding", },
2218 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2219 OPT_OUTPUT, { .func_arg = opt_attach },
2220 "add an attachment to the output file", "filename" },
2221 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2222 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2223 "extract an attachment into a file", "filename" },
2224 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
2225 "set CPU flags mask", "mask" },
2228 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2229 "set the number of video frames to record", "number" },
2230 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2231 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2232 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2233 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2234 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2235 "set frame size (WxH or abbreviation)", "size" },
2236 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2237 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2238 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2239 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2240 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2241 "set pixel format", "format" },
2242 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2244 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2245 "discard threshold", "n" },
2246 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2247 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2248 "rate control override for specific intervals", "override" },
2249 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2250 OPT_OUTPUT, { .func_arg = opt_video_codec },
2251 "force video codec ('copy' to copy stream)", "codec" },
2252 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2253 "select the pass number (1 or 2)", "n" },
2254 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2255 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2256 "select two pass log file name prefix", "prefix" },
2257 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2258 "dump video coding statistics to file" },
2259 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2260 "dump video coding statistics to file", "file" },
2261 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2262 "video filters", "filter list" },
2263 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2264 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2265 "specify intra matrix coeffs", "matrix" },
2266 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2267 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2268 "specify inter matrix coeffs", "matrix" },
2269 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2270 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2271 "top=1/bottom=0/auto=-1 field first", "" },
2272 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2273 "intra_dc_precision", "precision" },
2274 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2275 OPT_OUTPUT, { .func_arg = opt_video_tag },
2276 "force video tag/fourcc", "fourcc/tag" },
2277 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2278 "show QP histogram" },
2279 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2280 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2281 "force the selected framerate, disable the best supported framerate selection" },
2282 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2283 OPT_OUTPUT, { .func_arg = opt_streamid },
2284 "set the value of an outfile streamid", "streamIndex:value" },
2285 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2286 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2287 "force key frames at specified timestamps", "timestamps" },
2290 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2291 "set the number of audio frames to record", "number" },
2292 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2293 "set audio quality (codec-specific)", "quality", },
2294 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2295 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2296 "set audio sampling rate (in Hz)", "rate" },
2297 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2298 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2299 "set number of audio channels", "channels" },
2300 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2302 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2303 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2304 "force audio codec ('copy' to copy stream)", "codec" },
2305 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2306 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2307 "force audio tag/fourcc", "fourcc/tag" },
2308 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2309 "change audio volume (256=normal)" , "volume" },
2310 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2311 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2312 "set sample format", "format" },
2313 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2314 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2315 "set channel layout", "layout" },
2316 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2317 "audio filters", "filter list" },
2319 /* subtitle options */
2320 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2321 "disable subtitle" },
2322 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2323 "force subtitle codec ('copy' to copy stream)", "codec" },
2324 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2325 , "force subtitle tag/fourcc", "fourcc/tag" },
2328 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2331 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2332 "set the maximum demux-decode delay", "seconds" },
2333 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2334 "set the initial demux-decode delay", "seconds" },
2336 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2337 "A comma-separated list of bitstream filters", "bitstream_filters" },
2339 /* data codec support */
2340 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2341 "force data codec ('copy' to copy stream)", "codec" },