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->start_time = AV_NOPTS_VALUE;
117 o->recording_time = INT64_MAX;
118 o->limit_filesize = UINT64_MAX;
119 o->chapters_input_file = INT_MAX;
120 o->accurate_seek = 1;
123 /* return a copy of the input with the stream specifiers removed from the keys */
124 static AVDictionary *strip_specifiers(AVDictionary *dict)
126 AVDictionaryEntry *e = NULL;
127 AVDictionary *ret = NULL;
129 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
130 char *p = strchr(e->key, ':');
134 av_dict_set(&ret, e->key, e->value, 0);
141 static double parse_frame_aspect_ratio(const char *arg)
148 p = strchr(arg, ':');
150 x = strtol(arg, &end, 10);
152 y = strtol(end + 1, &end, 10);
154 ar = (double)x / (double)y;
156 ar = strtod(arg, NULL);
159 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
165 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
167 OptionsContext *o = optctx;
168 return parse_option(o, "codec:a", arg, options);
171 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
173 OptionsContext *o = optctx;
174 return parse_option(o, "codec:v", arg, options);
177 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
179 OptionsContext *o = optctx;
180 return parse_option(o, "codec:s", arg, options);
183 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
185 OptionsContext *o = optctx;
186 return parse_option(o, "codec:d", arg, options);
189 static int opt_map(void *optctx, const char *opt, const char *arg)
191 OptionsContext *o = optctx;
193 int i, negative = 0, file_idx;
194 int sync_file_idx = -1, sync_stream_idx;
202 map = av_strdup(arg);
204 /* parse sync stream first, just pick first matching stream */
205 if (sync = strchr(map, ',')) {
207 sync_file_idx = strtol(sync + 1, &sync, 0);
208 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
209 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
214 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
215 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
216 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
220 if (i == input_files[sync_file_idx]->nb_streams) {
221 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
222 "match any streams.\n", arg);
229 /* this mapping refers to lavfi output */
230 const char *c = map + 1;
231 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
232 m = &o->stream_maps[o->nb_stream_maps - 1];
233 m->linklabel = av_get_token(&c, "]");
235 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
239 file_idx = strtol(map, &p, 0);
240 if (file_idx >= nb_input_files || file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
245 /* disable some already defined maps */
246 for (i = 0; i < o->nb_stream_maps; i++) {
247 m = &o->stream_maps[i];
248 if (file_idx == m->file_index &&
249 check_stream_specifier(input_files[m->file_index]->ctx,
250 input_files[m->file_index]->ctx->streams[m->stream_index],
251 *p == ':' ? p + 1 : p) > 0)
255 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
256 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
257 *p == ':' ? p + 1 : p) <= 0)
259 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
260 m = &o->stream_maps[o->nb_stream_maps - 1];
262 m->file_index = file_idx;
265 if (sync_file_idx >= 0) {
266 m->sync_file_index = sync_file_idx;
267 m->sync_stream_index = sync_stream_idx;
269 m->sync_file_index = file_idx;
270 m->sync_stream_index = i;
276 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
284 static int opt_attach(void *optctx, const char *opt, const char *arg)
286 OptionsContext *o = optctx;
287 GROW_ARRAY(o->attachments, o->nb_attachments);
288 o->attachments[o->nb_attachments - 1] = arg;
293 * Parse a metadata specifier passed as 'arg' parameter.
294 * @param arg metadata string to parse
295 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
296 * @param index for type c/p, chapter/program index is written here
297 * @param stream_spec for type s, the stream specifier is written here
299 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
307 if (*(++arg) && *arg != ':') {
308 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
311 *stream_spec = *arg == ':' ? arg + 1 : "";
316 *index = strtol(++arg, NULL, 0);
319 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
326 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
328 AVDictionary **meta_in = NULL;
329 AVDictionary **meta_out;
331 char type_in, type_out;
332 const char *istream_spec = NULL, *ostream_spec = NULL;
333 int idx_in = 0, idx_out = 0;
335 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
336 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
338 if (type_in == 'g' || type_out == 'g')
339 o->metadata_global_manual = 1;
340 if (type_in == 's' || type_out == 's')
341 o->metadata_streams_manual = 1;
342 if (type_in == 'c' || type_out == 'c')
343 o->metadata_chapters_manual = 1;
345 /* ic is NULL when just disabling automatic mappings */
349 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
350 if ((index) < 0 || (index) >= (nb_elems)) {\
351 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
356 #define SET_DICT(type, meta, context, index)\
359 meta = &context->metadata;\
362 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
363 meta = &context->chapters[index]->metadata;\
366 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
367 meta = &context->programs[index]->metadata;\
370 break; /* handled separately below */ \
371 default: av_assert0(0);\
374 SET_DICT(type_in, meta_in, ic, idx_in);
375 SET_DICT(type_out, meta_out, oc, idx_out);
377 /* for input streams choose first matching stream */
378 if (type_in == 's') {
379 for (i = 0; i < ic->nb_streams; i++) {
380 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
381 meta_in = &ic->streams[i]->metadata;
387 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
392 if (type_out == 's') {
393 for (i = 0; i < oc->nb_streams; i++) {
394 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
395 meta_out = &oc->streams[i]->metadata;
396 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
401 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
406 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
408 const AVCodecDescriptor *desc;
409 const char *codec_string = encoder ? "encoder" : "decoder";
413 avcodec_find_encoder_by_name(name) :
414 avcodec_find_decoder_by_name(name);
416 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
417 codec = encoder ? avcodec_find_encoder(desc->id) :
418 avcodec_find_decoder(desc->id);
420 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
421 codec_string, codec->name, desc->name);
425 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
428 if (codec->type != type) {
429 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
435 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
437 char *codec_name = NULL;
439 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
441 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
442 st->codec->codec_id = codec->id;
445 return avcodec_find_decoder(st->codec->codec_id);
448 /* Add all the streams from the given input file to the global
449 * list of input streams. */
450 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
454 for (i = 0; i < ic->nb_streams; i++) {
455 AVStream *st = ic->streams[i];
456 AVCodecContext *dec = st->codec;
457 InputStream *ist = av_mallocz(sizeof(*ist));
458 char *framerate = NULL;
463 GROW_ARRAY(input_streams, nb_input_streams);
464 input_streams[nb_input_streams - 1] = ist;
467 ist->file_index = nb_input_files;
469 st->discard = AVDISCARD_ALL;
472 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
474 ist->dec = choose_decoder(o, ic, st);
475 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
477 switch (dec->codec_type) {
478 case AVMEDIA_TYPE_VIDEO:
479 ist->resample_height = dec->height;
480 ist->resample_width = dec->width;
481 ist->resample_pix_fmt = dec->pix_fmt;
483 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
484 if (framerate && av_parse_video_rate(&ist->framerate,
486 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
492 case AVMEDIA_TYPE_AUDIO:
493 guess_input_channel_layout(ist);
495 ist->resample_sample_fmt = dec->sample_fmt;
496 ist->resample_sample_rate = dec->sample_rate;
497 ist->resample_channels = dec->channels;
498 ist->resample_channel_layout = dec->channel_layout;
501 case AVMEDIA_TYPE_DATA:
502 case AVMEDIA_TYPE_SUBTITLE:
503 case AVMEDIA_TYPE_ATTACHMENT:
504 case AVMEDIA_TYPE_UNKNOWN:
512 static void assert_file_overwrite(const char *filename)
514 if (file_overwrite && file_skip) {
515 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
519 if (!file_overwrite &&
520 (strchr(filename, ':') == NULL || filename[1] == ':' ||
521 av_strstart(filename, "file:", NULL))) {
522 if (avio_check(filename, 0) == 0) {
523 if (!using_stdin && !file_skip) {
524 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
527 fprintf(stderr, "Not overwriting - exiting\n");
532 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
539 static void dump_attachment(AVStream *st, const char *filename)
542 AVIOContext *out = NULL;
543 AVDictionaryEntry *e;
545 if (!st->codec->extradata_size) {
546 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
547 nb_input_files - 1, st->index);
550 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
553 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
554 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
558 assert_file_overwrite(filename);
560 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
561 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
566 avio_write(out, st->codec->extradata, st->codec->extradata_size);
571 static int open_input_file(OptionsContext *o, const char *filename)
575 AVInputFormat *file_iformat = NULL;
580 AVDictionary *unused_opts = NULL;
581 AVDictionaryEntry *e = NULL;
582 int orig_nb_streams; // number of streams before avformat_find_stream_info
585 if (!(file_iformat = av_find_input_format(o->format))) {
586 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
591 if (!strcmp(filename, "-"))
594 using_stdin |= !strncmp(filename, "pipe:", 5) ||
595 !strcmp(filename, "/dev/stdin");
597 /* get default parameters from command line */
598 ic = avformat_alloc_context();
600 print_error(filename, AVERROR(ENOMEM));
603 if (o->nb_audio_sample_rate) {
604 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
605 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
607 if (o->nb_audio_channels) {
608 /* because we set audio_channels based on both the "ac" and
609 * "channel_layout" options, we need to check that the specified
610 * demuxer actually has the "channels" option before setting it */
611 if (file_iformat && file_iformat->priv_class &&
612 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
613 AV_OPT_SEARCH_FAKE_OBJ)) {
614 snprintf(buf, sizeof(buf), "%d",
615 o->audio_channels[o->nb_audio_channels - 1].u.i);
616 av_dict_set(&o->g->format_opts, "channels", buf, 0);
619 if (o->nb_frame_rates) {
620 /* set the format-level framerate option;
621 * this is important for video grabbers, e.g. x11 */
622 if (file_iformat && file_iformat->priv_class &&
623 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
624 AV_OPT_SEARCH_FAKE_OBJ)) {
625 av_dict_set(&o->g->format_opts, "framerate",
626 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
629 if (o->nb_frame_sizes) {
630 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
632 if (o->nb_frame_pix_fmts)
633 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
635 ic->flags |= AVFMT_FLAG_NONBLOCK;
636 ic->interrupt_callback = int_cb;
638 /* open the input file with generic libav function */
639 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
641 print_error(filename, err);
644 assert_avoptions(o->g->format_opts);
646 /* apply forced codec ids */
647 for (i = 0; i < ic->nb_streams; i++)
648 choose_decoder(o, ic, ic->streams[i]);
650 /* Set AVCodecContext options for avformat_find_stream_info */
651 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
652 orig_nb_streams = ic->nb_streams;
654 /* If not enough info to get the stream parameters, we decode the
655 first frames to get it. (used in mpeg case for example) */
656 ret = avformat_find_stream_info(ic, opts);
658 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
659 avformat_close_input(&ic);
663 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
664 /* add the stream start time */
665 if (ic->start_time != AV_NOPTS_VALUE)
666 timestamp += ic->start_time;
668 /* if seeking requested, we execute it */
669 if (o->start_time != AV_NOPTS_VALUE) {
670 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
672 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
673 filename, (double)timestamp / AV_TIME_BASE);
677 /* update the current parameters so that they match the one of the input stream */
678 add_input_streams(o, ic);
680 /* dump the file content */
681 av_dump_format(ic, nb_input_files, filename, 0);
683 GROW_ARRAY(input_files, nb_input_files);
684 f = av_mallocz(sizeof(*f));
687 input_files[nb_input_files - 1] = f;
690 f->ist_index = nb_input_streams - ic->nb_streams;
691 f->start_time = o->start_time;
692 f->recording_time = o->recording_time;
693 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
694 f->nb_streams = ic->nb_streams;
695 f->rate_emu = o->rate_emu;
696 f->accurate_seek = o->accurate_seek;
698 /* check if all codec options have been used */
699 unused_opts = strip_specifiers(o->g->codec_opts);
700 for (i = f->ist_index; i < nb_input_streams; i++) {
702 while ((e = av_dict_get(input_streams[i]->opts, "", e,
703 AV_DICT_IGNORE_SUFFIX)))
704 av_dict_set(&unused_opts, e->key, NULL, 0);
708 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
709 const AVClass *class = avcodec_get_class();
710 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
711 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
714 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
715 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
716 "input file #%d (%s) is not a decoding option.\n", e->key,
717 option->help ? option->help : "", nb_input_files - 1,
722 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
723 "input file #%d (%s) has not been used for any stream. The most "
724 "likely reason is either wrong type (e.g. a video option with "
725 "no video streams) or that it is a private option of some decoder "
726 "which was not actually used for any stream.\n", e->key,
727 option->help ? option->help : "", nb_input_files - 1, filename);
729 av_dict_free(&unused_opts);
731 for (i = 0; i < o->nb_dump_attachment; i++) {
734 for (j = 0; j < ic->nb_streams; j++) {
735 AVStream *st = ic->streams[j];
737 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
738 dump_attachment(st, o->dump_attachment[i].u.str);
742 for (i = 0; i < orig_nb_streams; i++)
743 av_dict_free(&opts[i]);
749 static uint8_t *get_line(AVIOContext *s)
755 if (avio_open_dyn_buf(&line) < 0) {
756 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
760 while ((c = avio_r8(s)) && c != '\n')
763 avio_close_dyn_buf(line, &buf);
768 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
772 const char *base[3] = { getenv("AVCONV_DATADIR"),
777 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
781 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
782 i != 1 ? "" : "/.avconv", codec_name, preset_name);
783 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
786 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
787 i != 1 ? "" : "/.avconv", preset_name);
788 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
794 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
796 char *codec_name = NULL;
798 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
800 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
801 NULL, ost->st->codec->codec_type);
802 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
803 } else if (!strcmp(codec_name, "copy"))
804 ost->stream_copy = 1;
806 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
807 ost->st->codec->codec_id = ost->enc->id;
811 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
814 AVStream *st = avformat_new_stream(oc, NULL);
815 int idx = oc->nb_streams - 1, ret = 0;
816 char *bsf = NULL, *next, *codec_tag = NULL;
817 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
821 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
825 if (oc->nb_streams - 1 < o->nb_streamid_map)
826 st->id = o->streamid_map[oc->nb_streams - 1];
828 GROW_ARRAY(output_streams, nb_output_streams);
829 if (!(ost = av_mallocz(sizeof(*ost))))
831 output_streams[nb_output_streams - 1] = ost;
833 ost->file_index = nb_output_files - 1;
836 st->codec->codec_type = type;
837 choose_encoder(o, oc, ost);
839 AVIOContext *s = NULL;
840 char *buf = NULL, *arg = NULL, *preset = NULL;
842 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
844 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
845 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
848 if (!buf[0] || buf[0] == '#') {
852 if (!(arg = strchr(buf, '='))) {
853 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
857 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
859 } while (!s->eof_reached);
863 av_log(NULL, AV_LOG_FATAL,
864 "Preset %s specified for stream %d:%d, but could not be opened.\n",
865 preset, ost->file_index, ost->index);
869 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
872 avcodec_get_context_defaults3(st->codec, ost->enc);
873 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
875 ost->max_frames = INT64_MAX;
876 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
878 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
880 if (next = strchr(bsf, ','))
882 if (!(bsfc = av_bitstream_filter_init(bsf))) {
883 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
887 bsfc_prev->next = bsfc;
889 ost->bitstream_filters = bsfc;
895 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
897 uint32_t tag = strtol(codec_tag, &next, 0);
899 tag = AV_RL32(codec_tag);
900 st->codec->codec_tag = tag;
903 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
905 st->codec->flags |= CODEC_FLAG_QSCALE;
906 st->codec->global_quality = FF_QP2LAMBDA * qscale;
909 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
910 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
912 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
914 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
916 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
917 ost->last_mux_dts = AV_NOPTS_VALUE;
922 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
932 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
939 /* read file contents into a string */
940 static uint8_t *read_file(const char *filename)
942 AVIOContext *pb = NULL;
943 AVIOContext *dyn_buf = NULL;
944 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
945 uint8_t buf[1024], *str;
948 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
952 ret = avio_open_dyn_buf(&dyn_buf);
957 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
958 avio_write(dyn_buf, buf, ret);
962 ret = avio_close_dyn_buf(dyn_buf, &str);
968 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
971 AVStream *st = ost->st;
972 char *filter = NULL, *filter_script = NULL;
974 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
975 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
977 if (filter_script && filter) {
978 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
979 "output stream #%d:%d.\n", nb_output_files, st->index);
984 return read_file(filter_script);
986 return av_strdup(filter);
988 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
992 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
996 AVCodecContext *video_enc;
997 char *frame_aspect_ratio = NULL;
999 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1001 video_enc = st->codec;
1003 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1004 if (frame_aspect_ratio)
1005 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1007 if (!ost->stream_copy) {
1008 const char *p = NULL;
1009 char *frame_rate = NULL, *frame_size = NULL;
1010 char *frame_pix_fmt = NULL;
1011 char *intra_matrix = NULL, *inter_matrix = NULL;
1015 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1016 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1017 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1021 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1022 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1023 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1027 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1028 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1029 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1032 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1034 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1036 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1037 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1040 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1042 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1044 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1045 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1048 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1051 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1052 for (i = 0; p; i++) {
1054 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1056 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1059 video_enc->rc_override =
1060 av_realloc(video_enc->rc_override,
1061 sizeof(RcOverride) * (i + 1));
1062 video_enc->rc_override[i].start_frame = start;
1063 video_enc->rc_override[i].end_frame = end;
1065 video_enc->rc_override[i].qscale = q;
1066 video_enc->rc_override[i].quality_factor = 1.0;
1069 video_enc->rc_override[i].qscale = 0;
1070 video_enc->rc_override[i].quality_factor = -q/100.0;
1075 video_enc->rc_override_count = i;
1076 video_enc->intra_dc_precision = intra_dc_precision - 8;
1079 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1082 video_enc->flags |= CODEC_FLAG_PASS1;
1084 video_enc->flags |= CODEC_FLAG_PASS2;
1088 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1089 if (ost->logfile_prefix &&
1090 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1093 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1094 if (ost->forced_keyframes)
1095 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1097 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1099 ost->top_field_first = -1;
1100 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1103 ost->avfilter = get_ost_filters(o, oc, ost);
1107 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1113 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1117 AVCodecContext *audio_enc;
1119 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1122 audio_enc = st->codec;
1123 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1125 if (!ost->stream_copy) {
1126 char *sample_fmt = NULL;
1128 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1130 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1132 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1133 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1137 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1139 ost->avfilter = get_ost_filters(o, oc, ost);
1147 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1151 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1152 if (!ost->stream_copy) {
1153 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1160 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1162 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1163 ost->stream_copy = 1;
1168 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1172 AVCodecContext *subtitle_enc;
1174 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1176 subtitle_enc = st->codec;
1178 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1183 /* arg format is "output-stream-index:streamid-value". */
1184 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1186 OptionsContext *o = optctx;
1191 av_strlcpy(idx_str, arg, sizeof(idx_str));
1192 p = strchr(idx_str, ':');
1194 av_log(NULL, AV_LOG_FATAL,
1195 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1200 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1201 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1202 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1206 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1208 AVFormatContext *is = ifile->ctx;
1209 AVFormatContext *os = ofile->ctx;
1213 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1215 return AVERROR(ENOMEM);
1218 for (i = 0; i < is->nb_chapters; i++) {
1219 AVChapter *in_ch = is->chapters[i], *out_ch;
1220 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1221 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1222 AV_TIME_BASE_Q, in_ch->time_base);
1223 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1224 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1227 if (in_ch->end < ts_off)
1229 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1232 out_ch = av_mallocz(sizeof(AVChapter));
1234 return AVERROR(ENOMEM);
1236 out_ch->id = in_ch->id;
1237 out_ch->time_base = in_ch->time_base;
1238 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1239 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1242 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1244 os->chapters[os->nb_chapters++] = out_ch;
1249 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1250 AVFormatContext *oc)
1254 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1255 ofilter->out_tmp->pad_idx)) {
1256 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1257 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1259 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1264 ost->source_index = -1;
1265 ost->filter = ofilter;
1269 if (ost->stream_copy) {
1270 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1271 "which is fed from a complex filtergraph. Filtering and streamcopy "
1272 "cannot be used together.\n", ost->file_index, ost->index);
1276 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1277 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1280 avfilter_inout_free(&ofilter->out_tmp);
1283 static int configure_complex_filters(void)
1287 for (i = 0; i < nb_filtergraphs; i++)
1288 if (!filtergraphs[i]->graph &&
1289 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1294 static int open_output_file(OptionsContext *o, const char *filename)
1296 AVFormatContext *oc;
1298 AVOutputFormat *file_oformat;
1302 AVDictionary *unused_opts = NULL;
1303 AVDictionaryEntry *e = NULL;
1305 if (configure_complex_filters() < 0) {
1306 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1310 GROW_ARRAY(output_files, nb_output_files);
1311 of = av_mallocz(sizeof(*of));
1314 output_files[nb_output_files - 1] = of;
1316 of->ost_index = nb_output_streams;
1317 of->recording_time = o->recording_time;
1318 of->start_time = o->start_time;
1319 of->limit_filesize = o->limit_filesize;
1320 of->shortest = o->shortest;
1321 av_dict_copy(&of->opts, o->g->format_opts, 0);
1323 if (!strcmp(filename, "-"))
1326 oc = avformat_alloc_context();
1328 print_error(filename, AVERROR(ENOMEM));
1332 if (o->recording_time != INT64_MAX)
1333 oc->duration = o->recording_time;
1336 file_oformat = av_guess_format(o->format, NULL, NULL);
1337 if (!file_oformat) {
1338 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1342 file_oformat = av_guess_format(NULL, filename, NULL);
1343 if (!file_oformat) {
1344 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1350 oc->oformat = file_oformat;
1351 oc->interrupt_callback = int_cb;
1352 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1354 /* create streams for all unlabeled output pads */
1355 for (i = 0; i < nb_filtergraphs; i++) {
1356 FilterGraph *fg = filtergraphs[i];
1357 for (j = 0; j < fg->nb_outputs; j++) {
1358 OutputFilter *ofilter = fg->outputs[j];
1360 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1363 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1364 ofilter->out_tmp->pad_idx)) {
1365 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1366 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1367 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1369 init_output_filter(ofilter, o, oc);
1373 if (!o->nb_stream_maps) {
1374 /* pick the "best" stream of each type */
1375 #define NEW_STREAM(type, index)\
1377 ost = new_ ## type ## _stream(o, oc);\
1378 ost->source_index = index;\
1379 ost->sync_ist = input_streams[index];\
1380 input_streams[index]->discard = 0;\
1381 input_streams[index]->st->discard = AVDISCARD_NONE;\
1384 /* video: highest resolution */
1385 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1386 int area = 0, idx = -1;
1387 for (i = 0; i < nb_input_streams; i++) {
1388 ist = input_streams[i];
1389 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1390 ist->st->codec->width * ist->st->codec->height > area) {
1391 area = ist->st->codec->width * ist->st->codec->height;
1395 NEW_STREAM(video, idx);
1398 /* audio: most channels */
1399 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1400 int channels = 0, idx = -1;
1401 for (i = 0; i < nb_input_streams; i++) {
1402 ist = input_streams[i];
1403 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1404 ist->st->codec->channels > channels) {
1405 channels = ist->st->codec->channels;
1409 NEW_STREAM(audio, idx);
1412 /* subtitles: pick first */
1413 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1414 for (i = 0; i < nb_input_streams; i++)
1415 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1416 NEW_STREAM(subtitle, i);
1420 /* do something with data? */
1422 for (i = 0; i < o->nb_stream_maps; i++) {
1423 StreamMap *map = &o->stream_maps[i];
1428 if (map->linklabel) {
1430 OutputFilter *ofilter = NULL;
1433 for (j = 0; j < nb_filtergraphs; j++) {
1434 fg = filtergraphs[j];
1435 for (k = 0; k < fg->nb_outputs; k++) {
1436 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1437 if (out && !strcmp(out->name, map->linklabel)) {
1438 ofilter = fg->outputs[k];
1445 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1446 "in any defined filter graph.\n", map->linklabel);
1449 init_output_filter(ofilter, o, oc);
1451 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1452 switch (ist->st->codec->codec_type) {
1453 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1454 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1455 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1456 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1457 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1459 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1460 map->file_index, map->stream_index);
1464 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1465 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1466 map->sync_stream_index];
1468 ist->st->discard = AVDISCARD_NONE;
1473 /* handle attached files */
1474 for (i = 0; i < o->nb_attachments; i++) {
1476 uint8_t *attachment;
1480 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1481 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1485 if ((len = avio_size(pb)) <= 0) {
1486 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1490 if (!(attachment = av_malloc(len))) {
1491 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1495 avio_read(pb, attachment, len);
1497 ost = new_attachment_stream(o, oc);
1498 ost->stream_copy = 0;
1499 ost->source_index = -1;
1500 ost->attachment_filename = o->attachments[i];
1501 ost->st->codec->extradata = attachment;
1502 ost->st->codec->extradata_size = len;
1504 p = strrchr(o->attachments[i], '/');
1505 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1509 /* check if all codec options have been used */
1510 unused_opts = strip_specifiers(o->g->codec_opts);
1511 for (i = of->ost_index; i < nb_output_streams; i++) {
1513 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1514 AV_DICT_IGNORE_SUFFIX)))
1515 av_dict_set(&unused_opts, e->key, NULL, 0);
1519 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1520 const AVClass *class = avcodec_get_class();
1521 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1522 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1525 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1526 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1527 "output file #%d (%s) is not an encoding option.\n", e->key,
1528 option->help ? option->help : "", nb_output_files - 1,
1533 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1534 "output file #%d (%s) has not been used for any stream. The most "
1535 "likely reason is either wrong type (e.g. a video option with "
1536 "no video streams) or that it is a private option of some encoder "
1537 "which was not actually used for any stream.\n", e->key,
1538 option->help ? option->help : "", nb_output_files - 1, filename);
1540 av_dict_free(&unused_opts);
1542 /* check filename in case of an image number is expected */
1543 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1544 if (!av_filename_number_test(oc->filename)) {
1545 print_error(oc->filename, AVERROR(EINVAL));
1550 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1551 /* test if it already exists to avoid losing precious files */
1552 assert_file_overwrite(filename);
1555 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1556 &oc->interrupt_callback,
1558 print_error(filename, err);
1563 if (o->mux_preload) {
1565 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1566 av_dict_set(&of->opts, "preload", buf, 0);
1568 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1569 oc->flags |= AVFMT_FLAG_NONBLOCK;
1572 for (i = 0; i < o->nb_metadata_map; i++) {
1574 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1576 if (in_file_index >= nb_input_files) {
1577 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1580 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1581 in_file_index >= 0 ?
1582 input_files[in_file_index]->ctx : NULL, o);
1586 if (o->chapters_input_file >= nb_input_files) {
1587 if (o->chapters_input_file == INT_MAX) {
1588 /* copy chapters from the first input file that has them*/
1589 o->chapters_input_file = -1;
1590 for (i = 0; i < nb_input_files; i++)
1591 if (input_files[i]->ctx->nb_chapters) {
1592 o->chapters_input_file = i;
1596 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1597 o->chapters_input_file);
1601 if (o->chapters_input_file >= 0)
1602 copy_chapters(input_files[o->chapters_input_file], of,
1603 !o->metadata_chapters_manual);
1605 /* copy global metadata by default */
1606 if (!o->metadata_global_manual && nb_input_files)
1607 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1608 AV_DICT_DONT_OVERWRITE);
1609 if (!o->metadata_streams_manual)
1610 for (i = of->ost_index; i < nb_output_streams; i++) {
1612 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1614 ist = input_streams[output_streams[i]->source_index];
1615 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1618 /* process manually set metadata */
1619 for (i = 0; i < o->nb_metadata; i++) {
1622 const char *stream_spec;
1623 int index = 0, j, ret;
1625 val = strchr(o->metadata[i].u.str, '=');
1627 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1628 o->metadata[i].u.str);
1633 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1635 for (j = 0; j < oc->nb_streams; j++) {
1636 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1637 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1648 if (index < 0 || index >= oc->nb_chapters) {
1649 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1652 m = &oc->chapters[index]->metadata;
1655 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1658 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1665 static int opt_target(void *optctx, const char *opt, const char *arg)
1667 OptionsContext *o = optctx;
1668 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1669 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1671 if (!strncmp(arg, "pal-", 4)) {
1674 } else if (!strncmp(arg, "ntsc-", 5)) {
1677 } else if (!strncmp(arg, "film-", 5)) {
1681 /* Try to determine PAL/NTSC by peeking in the input files */
1682 if (nb_input_files) {
1684 for (j = 0; j < nb_input_files; j++) {
1685 for (i = 0; i < input_files[j]->nb_streams; i++) {
1686 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1687 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1689 fr = c->time_base.den * 1000 / c->time_base.num;
1693 } else if ((fr == 29970) || (fr == 23976)) {
1698 if (norm != UNKNOWN)
1702 if (norm != UNKNOWN)
1703 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1706 if (norm == UNKNOWN) {
1707 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1708 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1709 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1713 if (!strcmp(arg, "vcd")) {
1714 opt_video_codec(o, "c:v", "mpeg1video");
1715 opt_audio_codec(o, "c:a", "mp2");
1716 parse_option(o, "f", "vcd", options);
1718 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1719 parse_option(o, "r", frame_rates[norm], options);
1720 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1722 opt_default(NULL, "b", "1150000");
1723 opt_default(NULL, "maxrate", "1150000");
1724 opt_default(NULL, "minrate", "1150000");
1725 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1727 opt_default(NULL, "b:a", "224000");
1728 parse_option(o, "ar", "44100", options);
1729 parse_option(o, "ac", "2", options);
1731 opt_default(NULL, "packetsize", "2324");
1732 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1734 /* We have to offset the PTS, so that it is consistent with the SCR.
1735 SCR starts at 36000, but the first two packs contain only padding
1736 and the first pack from the other stream, respectively, may also have
1737 been written before.
1738 So the real data starts at SCR 36000+3*1200. */
1739 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1740 } else if (!strcmp(arg, "svcd")) {
1742 opt_video_codec(o, "c:v", "mpeg2video");
1743 opt_audio_codec(o, "c:a", "mp2");
1744 parse_option(o, "f", "svcd", options);
1746 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1747 parse_option(o, "r", frame_rates[norm], options);
1748 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1750 opt_default(NULL, "b", "2040000");
1751 opt_default(NULL, "maxrate", "2516000");
1752 opt_default(NULL, "minrate", "0"); // 1145000;
1753 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1754 opt_default(NULL, "flags", "+scan_offset");
1757 opt_default(NULL, "b:a", "224000");
1758 parse_option(o, "ar", "44100", options);
1760 opt_default(NULL, "packetsize", "2324");
1762 } else if (!strcmp(arg, "dvd")) {
1764 opt_video_codec(o, "c:v", "mpeg2video");
1765 opt_audio_codec(o, "c:a", "ac3");
1766 parse_option(o, "f", "dvd", options);
1768 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1769 parse_option(o, "r", frame_rates[norm], options);
1770 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1772 opt_default(NULL, "b", "6000000");
1773 opt_default(NULL, "maxrate", "9000000");
1774 opt_default(NULL, "minrate", "0"); // 1500000;
1775 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1777 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1778 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1780 opt_default(NULL, "b:a", "448000");
1781 parse_option(o, "ar", "48000", options);
1783 } else if (!strncmp(arg, "dv", 2)) {
1785 parse_option(o, "f", "dv", options);
1787 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1788 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1789 norm == PAL ? "yuv420p" : "yuv411p", options);
1790 parse_option(o, "r", frame_rates[norm], options);
1792 parse_option(o, "ar", "48000", options);
1793 parse_option(o, "ac", "2", options);
1796 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1797 return AVERROR(EINVAL);
1802 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1804 av_free (vstats_filename);
1805 vstats_filename = av_strdup (arg);
1809 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1812 time_t today2 = time(NULL);
1813 struct tm *today = localtime(&today2);
1815 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1817 return opt_vstats_file(NULL, opt, filename);
1820 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1822 OptionsContext *o = optctx;
1823 return parse_option(o, "frames:v", arg, options);
1826 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1828 OptionsContext *o = optctx;
1829 return parse_option(o, "frames:a", arg, options);
1832 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1834 OptionsContext *o = optctx;
1835 return parse_option(o, "frames:d", arg, options);
1838 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1840 OptionsContext *o = optctx;
1841 return parse_option(o, "tag:v", arg, options);
1844 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1846 OptionsContext *o = optctx;
1847 return parse_option(o, "tag:a", arg, options);
1850 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1852 OptionsContext *o = optctx;
1853 return parse_option(o, "tag:s", arg, options);
1856 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1858 OptionsContext *o = optctx;
1859 return parse_option(o, "filter:v", arg, options);
1862 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1864 OptionsContext *o = optctx;
1865 return parse_option(o, "filter:a", arg, options);
1868 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1870 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1871 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1872 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1874 if (video_sync_method == VSYNC_AUTO)
1875 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1879 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1881 int flags = av_parse_cpu_flags(arg);
1886 av_set_cpu_flags_mask(flags);
1890 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1892 OptionsContext *o = optctx;
1893 char layout_str[32];
1896 int ret, channels, ac_str_size;
1899 layout = av_get_channel_layout(arg);
1901 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1902 return AVERROR(EINVAL);
1904 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1905 ret = opt_default(NULL, opt, layout_str);
1909 /* set 'ac' option based on channel layout */
1910 channels = av_get_channel_layout_nb_channels(layout);
1911 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1912 stream_str = strchr(opt, ':');
1913 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1914 ac_str = av_mallocz(ac_str_size);
1916 return AVERROR(ENOMEM);
1917 av_strlcpy(ac_str, "ac", 3);
1919 av_strlcat(ac_str, stream_str, ac_str_size);
1920 ret = parse_option(o, ac_str, layout_str, options);
1926 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1928 OptionsContext *o = optctx;
1929 return parse_option(o, "q:a", arg, options);
1932 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1934 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1935 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1936 return AVERROR(ENOMEM);
1937 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1938 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1939 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1940 return AVERROR(ENOMEM);
1944 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1946 uint8_t *graph_desc = read_file(arg);
1948 return AVERROR(EINVAL);
1950 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1951 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1952 return AVERROR(ENOMEM);
1953 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1954 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1958 void show_help_default(const char *opt, const char *arg)
1960 /* per-file options have at least one of those set */
1961 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1962 int show_advanced = 0, show_avoptions = 0;
1965 if (!strcmp(opt, "long"))
1967 else if (!strcmp(opt, "full"))
1968 show_advanced = show_avoptions = 1;
1970 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1975 printf("Getting help:\n"
1976 " -h -- print basic options\n"
1977 " -h long -- print more options\n"
1978 " -h full -- print all options (including all format and codec specific options, very long)\n"
1979 " See man %s for detailed description of the options.\n"
1980 "\n", program_name);
1982 show_help_options(options, "Print help / information / capabilities:",
1985 show_help_options(options, "Global options (affect whole program "
1986 "instead of just one file:",
1987 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1989 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1990 per_file | OPT_EXIT, 0);
1992 show_help_options(options, "Per-file main options:", 0,
1993 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1994 OPT_EXIT, per_file);
1996 show_help_options(options, "Advanced per-file options:",
1997 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1999 show_help_options(options, "Video options:",
2000 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2002 show_help_options(options, "Advanced Video options:",
2003 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2005 show_help_options(options, "Audio options:",
2006 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2008 show_help_options(options, "Advanced Audio options:",
2009 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2010 show_help_options(options, "Subtitle options:",
2011 OPT_SUBTITLE, 0, 0);
2014 if (show_avoptions) {
2015 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2016 show_help_children(avcodec_get_class(), flags);
2017 show_help_children(avformat_get_class(), flags);
2018 show_help_children(sws_get_class(), flags);
2019 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2023 void show_usage(void)
2025 printf("Hyper fast Audio and Video encoder\n");
2026 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2035 static const OptionGroupDef groups[] = {
2036 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2037 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2040 static int open_files(OptionGroupList *l, const char *inout,
2041 int (*open_file)(OptionsContext*, const char*))
2045 for (i = 0; i < l->nb_groups; i++) {
2046 OptionGroup *g = &l->groups[i];
2052 ret = parse_optgroup(&o, g);
2054 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2055 "%s.\n", inout, g->arg);
2059 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2060 ret = open_file(&o, g->arg);
2063 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2067 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2073 int avconv_parse_options(int argc, char **argv)
2075 OptionParseContext octx;
2079 memset(&octx, 0, sizeof(octx));
2081 /* split the commandline into an internal representation */
2082 ret = split_commandline(&octx, argc, argv, options, groups,
2083 FF_ARRAY_ELEMS(groups));
2085 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2089 /* apply global options */
2090 ret = parse_optgroup(NULL, &octx.global_opts);
2092 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2096 /* open input files */
2097 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2099 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2103 /* open output files */
2104 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2106 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2111 uninit_parse_context(&octx);
2113 av_strerror(ret, error, sizeof(error));
2114 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2119 #define OFFSET(x) offsetof(OptionsContext, x)
2120 const OptionDef options[] = {
2122 #include "cmdutils_common_opts.h"
2123 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2124 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2125 "force format", "fmt" },
2126 { "y", OPT_BOOL, { &file_overwrite },
2127 "overwrite output files" },
2128 { "n", OPT_BOOL, { &file_skip },
2129 "never overwrite output files" },
2130 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2131 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2132 "codec name", "codec" },
2133 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2134 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2135 "codec name", "codec" },
2136 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2137 OPT_OUTPUT, { .off = OFFSET(presets) },
2138 "preset name", "preset" },
2139 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2140 OPT_OUTPUT, { .func_arg = opt_map },
2141 "set input stream mapping",
2142 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2143 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2144 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2145 "set metadata information of outfile from infile",
2146 "outfile[,metadata]:infile[,metadata]" },
2147 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2148 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2149 "set chapters mapping", "input_file_index" },
2150 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2151 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2152 "record or transcode \"duration\" seconds of audio/video",
2154 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2155 "set the limit file size in bytes", "limit_size" },
2156 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2157 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2158 "set the start time offset", "time_off" },
2159 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2160 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2161 "enable/disable accurate seeking with -ss" },
2162 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2163 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2164 "set the input ts offset", "time_off" },
2165 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2166 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2167 "set the input ts scale", "scale" },
2168 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2169 "add metadata", "string=string" },
2170 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2171 OPT_OUTPUT, { .func_arg = opt_data_frames },
2172 "set the number of data frames to record", "number" },
2173 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2174 "add timings for benchmarking" },
2175 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2176 "set max runtime in seconds", "limit" },
2177 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2178 "dump each input packet" },
2179 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2180 "when dumping packets, also dump the payload" },
2181 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2182 OPT_INPUT, { .off = OFFSET(rate_emu) },
2183 "read input at native frame rate", "" },
2184 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2185 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2186 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2187 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2188 "video sync method", "" },
2189 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2190 "audio sync method", "" },
2191 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2192 "audio drift threshold", "threshold" },
2193 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2194 "copy timestamps" },
2195 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2196 "copy input stream time base when stream copying" },
2197 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2198 OPT_OUTPUT, { .off = OFFSET(shortest) },
2199 "finish encoding within shortest input" },
2200 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2201 "timestamp discontinuity delta threshold", "threshold" },
2202 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2203 "exit on error", "error" },
2204 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2205 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2206 "copy initial non-keyframes" },
2207 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2208 "set the number of frames to record", "number" },
2209 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2210 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2211 "force codec tag/fourcc", "fourcc/tag" },
2212 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2213 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2214 "use fixed quality scale (VBR)", "q" },
2215 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2216 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2217 "use fixed quality scale (VBR)", "q" },
2218 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2219 "set stream filterchain", "filter_list" },
2220 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2221 "read stream filtergraph description from a file", "filename" },
2222 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2223 "create a complex filtergraph", "graph_description" },
2224 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2225 "read complex filtergraph description from a file", "filename" },
2226 { "stats", OPT_BOOL, { &print_stats },
2227 "print progress report during encoding", },
2228 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2229 OPT_OUTPUT, { .func_arg = opt_attach },
2230 "add an attachment to the output file", "filename" },
2231 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2232 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2233 "extract an attachment into a file", "filename" },
2234 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
2235 "set CPU flags mask", "mask" },
2238 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2239 "set the number of video frames to record", "number" },
2240 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2241 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2242 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2243 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2244 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2245 "set frame size (WxH or abbreviation)", "size" },
2246 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2247 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2248 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2249 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2250 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2251 "set pixel format", "format" },
2252 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2254 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2255 "discard threshold", "n" },
2256 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2257 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2258 "rate control override for specific intervals", "override" },
2259 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2260 OPT_OUTPUT, { .func_arg = opt_video_codec },
2261 "force video codec ('copy' to copy stream)", "codec" },
2262 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2263 "select the pass number (1 or 2)", "n" },
2264 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2265 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2266 "select two pass log file name prefix", "prefix" },
2267 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2268 "dump video coding statistics to file" },
2269 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2270 "dump video coding statistics to file", "file" },
2271 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2272 "video filters", "filter list" },
2273 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2274 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2275 "specify intra matrix coeffs", "matrix" },
2276 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2277 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2278 "specify inter matrix coeffs", "matrix" },
2279 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2280 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2281 "top=1/bottom=0/auto=-1 field first", "" },
2282 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2283 "intra_dc_precision", "precision" },
2284 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2285 OPT_OUTPUT, { .func_arg = opt_video_tag },
2286 "force video tag/fourcc", "fourcc/tag" },
2287 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2288 "show QP histogram" },
2289 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2290 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2291 "force the selected framerate, disable the best supported framerate selection" },
2292 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2293 OPT_OUTPUT, { .func_arg = opt_streamid },
2294 "set the value of an outfile streamid", "streamIndex:value" },
2295 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2296 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2297 "force key frames at specified timestamps", "timestamps" },
2300 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2301 "set the number of audio frames to record", "number" },
2302 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2303 "set audio quality (codec-specific)", "quality", },
2304 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2305 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2306 "set audio sampling rate (in Hz)", "rate" },
2307 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2308 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2309 "set number of audio channels", "channels" },
2310 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2312 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2313 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2314 "force audio codec ('copy' to copy stream)", "codec" },
2315 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2316 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2317 "force audio tag/fourcc", "fourcc/tag" },
2318 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2319 "change audio volume (256=normal)" , "volume" },
2320 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2321 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2322 "set sample format", "format" },
2323 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2324 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2325 "set channel layout", "layout" },
2326 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2327 "audio filters", "filter list" },
2329 /* subtitle options */
2330 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2331 "disable subtitle" },
2332 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2333 "force subtitle codec ('copy' to copy stream)", "codec" },
2334 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2335 , "force subtitle tag/fourcc", "fourcc/tag" },
2338 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2341 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2342 "set the maximum demux-decode delay", "seconds" },
2343 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2344 "set the initial demux-decode delay", "seconds" },
2346 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2347 "A comma-separated list of bitstream filters", "bitstream_filters" },
2349 /* data codec support */
2350 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2351 "force data codec ('copy' to copy stream)", "codec" },