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 const HWAccel hwaccels[] = {
58 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
63 char *vstats_filename;
65 float audio_drift_threshold = 0.1;
66 float dts_delta_threshold = 10;
68 int audio_volume = 256;
69 int audio_sync_method = 0;
70 int video_sync_method = VSYNC_AUTO;
76 int exit_on_error = 0;
80 static int file_overwrite = 0;
81 static int file_skip = 0;
82 static int video_discard = 0;
83 static int intra_dc_precision = 8;
84 static int using_stdin = 0;
85 static int input_sync;
87 static void uninit_options(OptionsContext *o)
89 const OptionDef *po = options;
92 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
94 void *dst = (uint8_t*)o + po->u.off;
96 if (po->flags & OPT_SPEC) {
97 SpecifierOpt **so = dst;
98 int i, *count = (int*)(so + 1);
99 for (i = 0; i < *count; i++) {
100 av_freep(&(*so)[i].specifier);
101 if (po->flags & OPT_STRING)
102 av_freep(&(*so)[i].u.str);
106 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
111 for (i = 0; i < o->nb_stream_maps; i++)
112 av_freep(&o->stream_maps[i].linklabel);
113 av_freep(&o->stream_maps);
114 av_freep(&o->meta_data_maps);
115 av_freep(&o->streamid_map);
118 static void init_options(OptionsContext *o)
120 memset(o, 0, sizeof(*o));
122 o->mux_max_delay = 0.7;
123 o->start_time = AV_NOPTS_VALUE;
124 o->recording_time = INT64_MAX;
125 o->limit_filesize = UINT64_MAX;
126 o->chapters_input_file = INT_MAX;
127 o->accurate_seek = 1;
130 /* return a copy of the input with the stream specifiers removed from the keys */
131 static AVDictionary *strip_specifiers(AVDictionary *dict)
133 AVDictionaryEntry *e = NULL;
134 AVDictionary *ret = NULL;
136 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
137 char *p = strchr(e->key, ':');
141 av_dict_set(&ret, e->key, e->value, 0);
148 static double parse_frame_aspect_ratio(const char *arg)
155 p = strchr(arg, ':');
157 x = strtol(arg, &end, 10);
159 y = strtol(end + 1, &end, 10);
161 ar = (double)x / (double)y;
163 ar = strtod(arg, NULL);
166 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
172 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
174 OptionsContext *o = optctx;
175 return parse_option(o, "codec:a", arg, options);
178 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 return parse_option(o, "codec:v", arg, options);
184 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
186 OptionsContext *o = optctx;
187 return parse_option(o, "codec:s", arg, options);
190 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
192 OptionsContext *o = optctx;
193 return parse_option(o, "codec:d", arg, options);
196 static int opt_map(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
200 int i, negative = 0, file_idx;
201 int sync_file_idx = -1, sync_stream_idx;
209 map = av_strdup(arg);
211 /* parse sync stream first, just pick first matching stream */
212 if (sync = strchr(map, ',')) {
214 sync_file_idx = strtol(sync + 1, &sync, 0);
215 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
216 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
221 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
222 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
223 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
227 if (i == input_files[sync_file_idx]->nb_streams) {
228 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
229 "match any streams.\n", arg);
236 /* this mapping refers to lavfi output */
237 const char *c = map + 1;
238 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
239 m = &o->stream_maps[o->nb_stream_maps - 1];
240 m->linklabel = av_get_token(&c, "]");
242 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
246 file_idx = strtol(map, &p, 0);
247 if (file_idx >= nb_input_files || file_idx < 0) {
248 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
252 /* disable some already defined maps */
253 for (i = 0; i < o->nb_stream_maps; i++) {
254 m = &o->stream_maps[i];
255 if (file_idx == m->file_index &&
256 check_stream_specifier(input_files[m->file_index]->ctx,
257 input_files[m->file_index]->ctx->streams[m->stream_index],
258 *p == ':' ? p + 1 : p) > 0)
262 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
263 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
264 *p == ':' ? p + 1 : p) <= 0)
266 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
267 m = &o->stream_maps[o->nb_stream_maps - 1];
269 m->file_index = file_idx;
272 if (sync_file_idx >= 0) {
273 m->sync_file_index = sync_file_idx;
274 m->sync_stream_index = sync_stream_idx;
276 m->sync_file_index = file_idx;
277 m->sync_stream_index = i;
283 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
291 static int opt_attach(void *optctx, const char *opt, const char *arg)
293 OptionsContext *o = optctx;
294 GROW_ARRAY(o->attachments, o->nb_attachments);
295 o->attachments[o->nb_attachments - 1] = arg;
300 * Parse a metadata specifier passed as 'arg' parameter.
301 * @param arg metadata string to parse
302 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
303 * @param index for type c/p, chapter/program index is written here
304 * @param stream_spec for type s, the stream specifier is written here
306 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
314 if (*(++arg) && *arg != ':') {
315 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
318 *stream_spec = *arg == ':' ? arg + 1 : "";
323 *index = strtol(++arg, NULL, 0);
326 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
333 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
335 AVDictionary **meta_in = NULL;
336 AVDictionary **meta_out;
338 char type_in, type_out;
339 const char *istream_spec = NULL, *ostream_spec = NULL;
340 int idx_in = 0, idx_out = 0;
342 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
343 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
345 if (type_in == 'g' || type_out == 'g')
346 o->metadata_global_manual = 1;
347 if (type_in == 's' || type_out == 's')
348 o->metadata_streams_manual = 1;
349 if (type_in == 'c' || type_out == 'c')
350 o->metadata_chapters_manual = 1;
352 /* ic is NULL when just disabling automatic mappings */
356 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
357 if ((index) < 0 || (index) >= (nb_elems)) {\
358 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
363 #define SET_DICT(type, meta, context, index)\
366 meta = &context->metadata;\
369 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
370 meta = &context->chapters[index]->metadata;\
373 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
374 meta = &context->programs[index]->metadata;\
377 break; /* handled separately below */ \
378 default: av_assert0(0);\
381 SET_DICT(type_in, meta_in, ic, idx_in);
382 SET_DICT(type_out, meta_out, oc, idx_out);
384 /* for input streams choose first matching stream */
385 if (type_in == 's') {
386 for (i = 0; i < ic->nb_streams; i++) {
387 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
388 meta_in = &ic->streams[i]->metadata;
394 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
399 if (type_out == 's') {
400 for (i = 0; i < oc->nb_streams; i++) {
401 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
402 meta_out = &oc->streams[i]->metadata;
403 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
408 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
413 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
415 const AVCodecDescriptor *desc;
416 const char *codec_string = encoder ? "encoder" : "decoder";
420 avcodec_find_encoder_by_name(name) :
421 avcodec_find_decoder_by_name(name);
423 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
424 codec = encoder ? avcodec_find_encoder(desc->id) :
425 avcodec_find_decoder(desc->id);
427 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
428 codec_string, codec->name, desc->name);
432 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
435 if (codec->type != type) {
436 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
442 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
444 char *codec_name = NULL;
446 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
448 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
449 st->codec->codec_id = codec->id;
452 return avcodec_find_decoder(st->codec->codec_id);
455 /* Add all the streams from the given input file to the global
456 * list of input streams. */
457 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
461 for (i = 0; i < ic->nb_streams; i++) {
462 AVStream *st = ic->streams[i];
463 AVCodecContext *dec = st->codec;
464 InputStream *ist = av_mallocz(sizeof(*ist));
465 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
470 GROW_ARRAY(input_streams, nb_input_streams);
471 input_streams[nb_input_streams - 1] = ist;
474 ist->file_index = nb_input_files;
476 st->discard = AVDISCARD_ALL;
479 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
481 ist->dec = choose_decoder(o, ic, st);
482 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
484 switch (dec->codec_type) {
485 case AVMEDIA_TYPE_VIDEO:
486 ist->resample_height = dec->height;
487 ist->resample_width = dec->width;
488 ist->resample_pix_fmt = dec->pix_fmt;
490 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
491 if (framerate && av_parse_video_rate(&ist->framerate,
493 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
498 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
500 if (!strcmp(hwaccel, "none"))
501 ist->hwaccel_id = HWACCEL_NONE;
502 else if (!strcmp(hwaccel, "auto"))
503 ist->hwaccel_id = HWACCEL_AUTO;
506 for (i = 0; hwaccels[i].name; i++) {
507 if (!strcmp(hwaccels[i].name, hwaccel)) {
508 ist->hwaccel_id = hwaccels[i].id;
513 if (!ist->hwaccel_id) {
514 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
516 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
517 for (i = 0; hwaccels[i].name; i++)
518 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
519 av_log(NULL, AV_LOG_FATAL, "\n");
525 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
526 if (hwaccel_device) {
527 ist->hwaccel_device = av_strdup(hwaccel_device);
528 if (!ist->hwaccel_device)
531 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
534 case AVMEDIA_TYPE_AUDIO:
535 guess_input_channel_layout(ist);
537 ist->resample_sample_fmt = dec->sample_fmt;
538 ist->resample_sample_rate = dec->sample_rate;
539 ist->resample_channels = dec->channels;
540 ist->resample_channel_layout = dec->channel_layout;
543 case AVMEDIA_TYPE_DATA:
544 case AVMEDIA_TYPE_SUBTITLE:
545 case AVMEDIA_TYPE_ATTACHMENT:
546 case AVMEDIA_TYPE_UNKNOWN:
554 static void assert_file_overwrite(const char *filename)
556 if (file_overwrite && file_skip) {
557 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
561 if (!file_overwrite &&
562 (strchr(filename, ':') == NULL || filename[1] == ':' ||
563 av_strstart(filename, "file:", NULL))) {
564 if (avio_check(filename, 0) == 0) {
565 if (!using_stdin && !file_skip) {
566 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
569 fprintf(stderr, "Not overwriting - exiting\n");
574 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
581 static void dump_attachment(AVStream *st, const char *filename)
584 AVIOContext *out = NULL;
585 AVDictionaryEntry *e;
587 if (!st->codec->extradata_size) {
588 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
589 nb_input_files - 1, st->index);
592 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
595 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
596 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
600 assert_file_overwrite(filename);
602 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
603 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
608 avio_write(out, st->codec->extradata, st->codec->extradata_size);
613 static int open_input_file(OptionsContext *o, const char *filename)
617 AVInputFormat *file_iformat = NULL;
622 AVDictionary *unused_opts = NULL;
623 AVDictionaryEntry *e = NULL;
624 int orig_nb_streams; // number of streams before avformat_find_stream_info
627 if (!(file_iformat = av_find_input_format(o->format))) {
628 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
633 if (!strcmp(filename, "-"))
636 using_stdin |= !strncmp(filename, "pipe:", 5) ||
637 !strcmp(filename, "/dev/stdin");
639 /* get default parameters from command line */
640 ic = avformat_alloc_context();
642 print_error(filename, AVERROR(ENOMEM));
645 if (o->nb_audio_sample_rate) {
646 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
647 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
649 if (o->nb_audio_channels) {
650 /* because we set audio_channels based on both the "ac" and
651 * "channel_layout" options, we need to check that the specified
652 * demuxer actually has the "channels" option before setting it */
653 if (file_iformat && file_iformat->priv_class &&
654 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
655 AV_OPT_SEARCH_FAKE_OBJ)) {
656 snprintf(buf, sizeof(buf), "%d",
657 o->audio_channels[o->nb_audio_channels - 1].u.i);
658 av_dict_set(&o->g->format_opts, "channels", buf, 0);
661 if (o->nb_frame_rates) {
662 /* set the format-level framerate option;
663 * this is important for video grabbers, e.g. x11 */
664 if (file_iformat && file_iformat->priv_class &&
665 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
666 AV_OPT_SEARCH_FAKE_OBJ)) {
667 av_dict_set(&o->g->format_opts, "framerate",
668 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
671 if (o->nb_frame_sizes) {
672 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
674 if (o->nb_frame_pix_fmts)
675 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
677 ic->flags |= AVFMT_FLAG_NONBLOCK;
678 ic->interrupt_callback = int_cb;
680 /* open the input file with generic libav function */
681 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
683 print_error(filename, err);
686 assert_avoptions(o->g->format_opts);
688 /* apply forced codec ids */
689 for (i = 0; i < ic->nb_streams; i++)
690 choose_decoder(o, ic, ic->streams[i]);
692 /* Set AVCodecContext options for avformat_find_stream_info */
693 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
694 orig_nb_streams = ic->nb_streams;
696 /* If not enough info to get the stream parameters, we decode the
697 first frames to get it. (used in mpeg case for example) */
698 ret = avformat_find_stream_info(ic, opts);
700 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
701 avformat_close_input(&ic);
705 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
706 /* add the stream start time */
707 if (ic->start_time != AV_NOPTS_VALUE)
708 timestamp += ic->start_time;
710 /* if seeking requested, we execute it */
711 if (o->start_time != AV_NOPTS_VALUE) {
712 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
714 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
715 filename, (double)timestamp / AV_TIME_BASE);
719 /* update the current parameters so that they match the one of the input stream */
720 add_input_streams(o, ic);
722 /* dump the file content */
723 av_dump_format(ic, nb_input_files, filename, 0);
725 GROW_ARRAY(input_files, nb_input_files);
726 f = av_mallocz(sizeof(*f));
729 input_files[nb_input_files - 1] = f;
732 f->ist_index = nb_input_streams - ic->nb_streams;
733 f->start_time = o->start_time;
734 f->recording_time = o->recording_time;
735 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
736 f->nb_streams = ic->nb_streams;
737 f->rate_emu = o->rate_emu;
738 f->accurate_seek = o->accurate_seek;
740 /* check if all codec options have been used */
741 unused_opts = strip_specifiers(o->g->codec_opts);
742 for (i = f->ist_index; i < nb_input_streams; i++) {
744 while ((e = av_dict_get(input_streams[i]->opts, "", e,
745 AV_DICT_IGNORE_SUFFIX)))
746 av_dict_set(&unused_opts, e->key, NULL, 0);
750 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
751 const AVClass *class = avcodec_get_class();
752 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
753 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
756 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
757 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
758 "input file #%d (%s) is not a decoding option.\n", e->key,
759 option->help ? option->help : "", nb_input_files - 1,
764 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
765 "input file #%d (%s) has not been used for any stream. The most "
766 "likely reason is either wrong type (e.g. a video option with "
767 "no video streams) or that it is a private option of some decoder "
768 "which was not actually used for any stream.\n", e->key,
769 option->help ? option->help : "", nb_input_files - 1, filename);
771 av_dict_free(&unused_opts);
773 for (i = 0; i < o->nb_dump_attachment; i++) {
776 for (j = 0; j < ic->nb_streams; j++) {
777 AVStream *st = ic->streams[j];
779 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
780 dump_attachment(st, o->dump_attachment[i].u.str);
784 for (i = 0; i < orig_nb_streams; i++)
785 av_dict_free(&opts[i]);
791 static uint8_t *get_line(AVIOContext *s)
797 if (avio_open_dyn_buf(&line) < 0) {
798 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
802 while ((c = avio_r8(s)) && c != '\n')
805 avio_close_dyn_buf(line, &buf);
810 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
814 const char *base[3] = { getenv("AVCONV_DATADIR"),
819 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
823 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
824 i != 1 ? "" : "/.avconv", codec_name, preset_name);
825 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
828 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
829 i != 1 ? "" : "/.avconv", preset_name);
830 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
836 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
838 char *codec_name = NULL;
840 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
842 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
843 NULL, ost->st->codec->codec_type);
844 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
845 } else if (!strcmp(codec_name, "copy"))
846 ost->stream_copy = 1;
848 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
849 ost->st->codec->codec_id = ost->enc->id;
853 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
856 AVStream *st = avformat_new_stream(oc, NULL);
857 int idx = oc->nb_streams - 1, ret = 0;
858 char *bsf = NULL, *next, *codec_tag = NULL;
859 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
863 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
867 if (oc->nb_streams - 1 < o->nb_streamid_map)
868 st->id = o->streamid_map[oc->nb_streams - 1];
870 GROW_ARRAY(output_streams, nb_output_streams);
871 if (!(ost = av_mallocz(sizeof(*ost))))
873 output_streams[nb_output_streams - 1] = ost;
875 ost->file_index = nb_output_files - 1;
878 st->codec->codec_type = type;
879 choose_encoder(o, oc, ost);
881 AVIOContext *s = NULL;
882 char *buf = NULL, *arg = NULL, *preset = NULL;
884 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
886 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
887 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
890 if (!buf[0] || buf[0] == '#') {
894 if (!(arg = strchr(buf, '='))) {
895 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
899 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
901 } while (!s->eof_reached);
905 av_log(NULL, AV_LOG_FATAL,
906 "Preset %s specified for stream %d:%d, but could not be opened.\n",
907 preset, ost->file_index, ost->index);
911 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
914 avcodec_get_context_defaults3(st->codec, ost->enc);
915 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
917 ost->max_frames = INT64_MAX;
918 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
920 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
922 if (next = strchr(bsf, ','))
924 if (!(bsfc = av_bitstream_filter_init(bsf))) {
925 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
929 bsfc_prev->next = bsfc;
931 ost->bitstream_filters = bsfc;
937 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
939 uint32_t tag = strtol(codec_tag, &next, 0);
941 tag = AV_RL32(codec_tag);
942 st->codec->codec_tag = tag;
945 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
947 st->codec->flags |= CODEC_FLAG_QSCALE;
948 st->codec->global_quality = FF_QP2LAMBDA * qscale;
951 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
952 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
954 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
956 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
958 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
959 ost->last_mux_dts = AV_NOPTS_VALUE;
964 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
974 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
981 /* read file contents into a string */
982 static uint8_t *read_file(const char *filename)
984 AVIOContext *pb = NULL;
985 AVIOContext *dyn_buf = NULL;
986 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
987 uint8_t buf[1024], *str;
990 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
994 ret = avio_open_dyn_buf(&dyn_buf);
999 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1000 avio_write(dyn_buf, buf, ret);
1001 avio_w8(dyn_buf, 0);
1004 ret = avio_close_dyn_buf(dyn_buf, &str);
1010 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1013 AVStream *st = ost->st;
1014 char *filter = NULL, *filter_script = NULL;
1016 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1017 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1019 if (filter_script && filter) {
1020 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1021 "output stream #%d:%d.\n", nb_output_files, st->index);
1026 return read_file(filter_script);
1028 return av_strdup(filter);
1030 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1034 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1038 AVCodecContext *video_enc;
1039 char *frame_aspect_ratio = NULL;
1041 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1043 video_enc = st->codec;
1045 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1046 if (frame_aspect_ratio)
1047 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1049 if (!ost->stream_copy) {
1050 const char *p = NULL;
1051 char *frame_rate = NULL, *frame_size = NULL;
1052 char *frame_pix_fmt = NULL;
1053 char *intra_matrix = NULL, *inter_matrix = NULL;
1057 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1058 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1059 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1063 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1064 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1065 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1069 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1070 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1071 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1074 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1076 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1078 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1079 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1082 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1084 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1086 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1087 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1090 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1093 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1094 for (i = 0; p; i++) {
1096 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1098 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1101 video_enc->rc_override =
1102 av_realloc(video_enc->rc_override,
1103 sizeof(RcOverride) * (i + 1));
1104 video_enc->rc_override[i].start_frame = start;
1105 video_enc->rc_override[i].end_frame = end;
1107 video_enc->rc_override[i].qscale = q;
1108 video_enc->rc_override[i].quality_factor = 1.0;
1111 video_enc->rc_override[i].qscale = 0;
1112 video_enc->rc_override[i].quality_factor = -q/100.0;
1117 video_enc->rc_override_count = i;
1118 video_enc->intra_dc_precision = intra_dc_precision - 8;
1121 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1124 video_enc->flags |= CODEC_FLAG_PASS1;
1126 video_enc->flags |= CODEC_FLAG_PASS2;
1130 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1131 if (ost->logfile_prefix &&
1132 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1135 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1136 if (ost->forced_keyframes)
1137 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1139 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1141 ost->top_field_first = -1;
1142 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1145 ost->avfilter = get_ost_filters(o, oc, ost);
1149 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1155 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1159 AVCodecContext *audio_enc;
1161 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1164 audio_enc = st->codec;
1165 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1167 if (!ost->stream_copy) {
1168 char *sample_fmt = NULL;
1170 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1172 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1174 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1175 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1179 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1181 ost->avfilter = get_ost_filters(o, oc, ost);
1189 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1193 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1194 if (!ost->stream_copy) {
1195 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1202 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1204 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1205 ost->stream_copy = 1;
1210 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1214 AVCodecContext *subtitle_enc;
1216 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1218 subtitle_enc = st->codec;
1220 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1225 /* arg format is "output-stream-index:streamid-value". */
1226 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1228 OptionsContext *o = optctx;
1233 av_strlcpy(idx_str, arg, sizeof(idx_str));
1234 p = strchr(idx_str, ':');
1236 av_log(NULL, AV_LOG_FATAL,
1237 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1242 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1243 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1244 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1248 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1250 AVFormatContext *is = ifile->ctx;
1251 AVFormatContext *os = ofile->ctx;
1255 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1257 return AVERROR(ENOMEM);
1260 for (i = 0; i < is->nb_chapters; i++) {
1261 AVChapter *in_ch = is->chapters[i], *out_ch;
1262 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1263 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1264 AV_TIME_BASE_Q, in_ch->time_base);
1265 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1266 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1269 if (in_ch->end < ts_off)
1271 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1274 out_ch = av_mallocz(sizeof(AVChapter));
1276 return AVERROR(ENOMEM);
1278 out_ch->id = in_ch->id;
1279 out_ch->time_base = in_ch->time_base;
1280 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1281 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1284 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1286 os->chapters[os->nb_chapters++] = out_ch;
1291 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1292 AVFormatContext *oc)
1296 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1297 ofilter->out_tmp->pad_idx)) {
1298 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1299 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1301 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1306 ost->source_index = -1;
1307 ost->filter = ofilter;
1311 if (ost->stream_copy) {
1312 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1313 "which is fed from a complex filtergraph. Filtering and streamcopy "
1314 "cannot be used together.\n", ost->file_index, ost->index);
1318 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1319 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1322 avfilter_inout_free(&ofilter->out_tmp);
1325 static int configure_complex_filters(void)
1329 for (i = 0; i < nb_filtergraphs; i++)
1330 if (!filtergraphs[i]->graph &&
1331 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1336 static int open_output_file(OptionsContext *o, const char *filename)
1338 AVFormatContext *oc;
1340 AVOutputFormat *file_oformat;
1344 AVDictionary *unused_opts = NULL;
1345 AVDictionaryEntry *e = NULL;
1347 if (configure_complex_filters() < 0) {
1348 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1352 GROW_ARRAY(output_files, nb_output_files);
1353 of = av_mallocz(sizeof(*of));
1356 output_files[nb_output_files - 1] = of;
1358 of->ost_index = nb_output_streams;
1359 of->recording_time = o->recording_time;
1360 of->start_time = o->start_time;
1361 of->limit_filesize = o->limit_filesize;
1362 of->shortest = o->shortest;
1363 av_dict_copy(&of->opts, o->g->format_opts, 0);
1365 if (!strcmp(filename, "-"))
1368 oc = avformat_alloc_context();
1370 print_error(filename, AVERROR(ENOMEM));
1374 if (o->recording_time != INT64_MAX)
1375 oc->duration = o->recording_time;
1378 file_oformat = av_guess_format(o->format, NULL, NULL);
1379 if (!file_oformat) {
1380 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1384 file_oformat = av_guess_format(NULL, filename, NULL);
1385 if (!file_oformat) {
1386 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1392 oc->oformat = file_oformat;
1393 oc->interrupt_callback = int_cb;
1394 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1396 /* create streams for all unlabeled output pads */
1397 for (i = 0; i < nb_filtergraphs; i++) {
1398 FilterGraph *fg = filtergraphs[i];
1399 for (j = 0; j < fg->nb_outputs; j++) {
1400 OutputFilter *ofilter = fg->outputs[j];
1402 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1405 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1406 ofilter->out_tmp->pad_idx)) {
1407 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1408 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1409 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1411 init_output_filter(ofilter, o, oc);
1415 if (!o->nb_stream_maps) {
1416 /* pick the "best" stream of each type */
1417 #define NEW_STREAM(type, index)\
1419 ost = new_ ## type ## _stream(o, oc);\
1420 ost->source_index = index;\
1421 ost->sync_ist = input_streams[index];\
1422 input_streams[index]->discard = 0;\
1423 input_streams[index]->st->discard = AVDISCARD_NONE;\
1426 /* video: highest resolution */
1427 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1428 int area = 0, idx = -1;
1429 for (i = 0; i < nb_input_streams; i++) {
1430 ist = input_streams[i];
1431 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1432 ist->st->codec->width * ist->st->codec->height > area) {
1433 area = ist->st->codec->width * ist->st->codec->height;
1437 NEW_STREAM(video, idx);
1440 /* audio: most channels */
1441 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1442 int channels = 0, idx = -1;
1443 for (i = 0; i < nb_input_streams; i++) {
1444 ist = input_streams[i];
1445 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1446 ist->st->codec->channels > channels) {
1447 channels = ist->st->codec->channels;
1451 NEW_STREAM(audio, idx);
1454 /* subtitles: pick first */
1455 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1456 for (i = 0; i < nb_input_streams; i++)
1457 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1458 NEW_STREAM(subtitle, i);
1462 /* do something with data? */
1464 for (i = 0; i < o->nb_stream_maps; i++) {
1465 StreamMap *map = &o->stream_maps[i];
1470 if (map->linklabel) {
1472 OutputFilter *ofilter = NULL;
1475 for (j = 0; j < nb_filtergraphs; j++) {
1476 fg = filtergraphs[j];
1477 for (k = 0; k < fg->nb_outputs; k++) {
1478 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1479 if (out && !strcmp(out->name, map->linklabel)) {
1480 ofilter = fg->outputs[k];
1487 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1488 "in any defined filter graph.\n", map->linklabel);
1491 init_output_filter(ofilter, o, oc);
1493 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1494 switch (ist->st->codec->codec_type) {
1495 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1496 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1497 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1498 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1499 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1501 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1502 map->file_index, map->stream_index);
1506 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1507 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1508 map->sync_stream_index];
1510 ist->st->discard = AVDISCARD_NONE;
1515 /* handle attached files */
1516 for (i = 0; i < o->nb_attachments; i++) {
1518 uint8_t *attachment;
1522 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1523 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1527 if ((len = avio_size(pb)) <= 0) {
1528 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1532 if (!(attachment = av_malloc(len))) {
1533 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1537 avio_read(pb, attachment, len);
1539 ost = new_attachment_stream(o, oc);
1540 ost->stream_copy = 0;
1541 ost->source_index = -1;
1542 ost->attachment_filename = o->attachments[i];
1543 ost->st->codec->extradata = attachment;
1544 ost->st->codec->extradata_size = len;
1546 p = strrchr(o->attachments[i], '/');
1547 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1551 /* check if all codec options have been used */
1552 unused_opts = strip_specifiers(o->g->codec_opts);
1553 for (i = of->ost_index; i < nb_output_streams; i++) {
1555 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1556 AV_DICT_IGNORE_SUFFIX)))
1557 av_dict_set(&unused_opts, e->key, NULL, 0);
1561 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1562 const AVClass *class = avcodec_get_class();
1563 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1564 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1567 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1568 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1569 "output file #%d (%s) is not an encoding option.\n", e->key,
1570 option->help ? option->help : "", nb_output_files - 1,
1575 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1576 "output file #%d (%s) has not been used for any stream. The most "
1577 "likely reason is either wrong type (e.g. a video option with "
1578 "no video streams) or that it is a private option of some encoder "
1579 "which was not actually used for any stream.\n", e->key,
1580 option->help ? option->help : "", nb_output_files - 1, filename);
1582 av_dict_free(&unused_opts);
1584 /* check filename in case of an image number is expected */
1585 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1586 if (!av_filename_number_test(oc->filename)) {
1587 print_error(oc->filename, AVERROR(EINVAL));
1592 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1593 /* test if it already exists to avoid losing precious files */
1594 assert_file_overwrite(filename);
1597 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1598 &oc->interrupt_callback,
1600 print_error(filename, err);
1605 if (o->mux_preload) {
1607 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1608 av_dict_set(&of->opts, "preload", buf, 0);
1610 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1611 oc->flags |= AVFMT_FLAG_NONBLOCK;
1614 for (i = 0; i < o->nb_metadata_map; i++) {
1616 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1618 if (in_file_index >= nb_input_files) {
1619 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1622 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1623 in_file_index >= 0 ?
1624 input_files[in_file_index]->ctx : NULL, o);
1628 if (o->chapters_input_file >= nb_input_files) {
1629 if (o->chapters_input_file == INT_MAX) {
1630 /* copy chapters from the first input file that has them*/
1631 o->chapters_input_file = -1;
1632 for (i = 0; i < nb_input_files; i++)
1633 if (input_files[i]->ctx->nb_chapters) {
1634 o->chapters_input_file = i;
1638 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1639 o->chapters_input_file);
1643 if (o->chapters_input_file >= 0)
1644 copy_chapters(input_files[o->chapters_input_file], of,
1645 !o->metadata_chapters_manual);
1647 /* copy global metadata by default */
1648 if (!o->metadata_global_manual && nb_input_files)
1649 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1650 AV_DICT_DONT_OVERWRITE);
1651 if (!o->metadata_streams_manual)
1652 for (i = of->ost_index; i < nb_output_streams; i++) {
1654 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1656 ist = input_streams[output_streams[i]->source_index];
1657 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1660 /* process manually set metadata */
1661 for (i = 0; i < o->nb_metadata; i++) {
1664 const char *stream_spec;
1665 int index = 0, j, ret;
1667 val = strchr(o->metadata[i].u.str, '=');
1669 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1670 o->metadata[i].u.str);
1675 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1677 for (j = 0; j < oc->nb_streams; j++) {
1678 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1679 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1690 if (index < 0 || index >= oc->nb_chapters) {
1691 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1694 m = &oc->chapters[index]->metadata;
1697 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1700 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1707 static int opt_target(void *optctx, const char *opt, const char *arg)
1709 OptionsContext *o = optctx;
1710 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1711 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1713 if (!strncmp(arg, "pal-", 4)) {
1716 } else if (!strncmp(arg, "ntsc-", 5)) {
1719 } else if (!strncmp(arg, "film-", 5)) {
1723 /* Try to determine PAL/NTSC by peeking in the input files */
1724 if (nb_input_files) {
1726 for (j = 0; j < nb_input_files; j++) {
1727 for (i = 0; i < input_files[j]->nb_streams; i++) {
1728 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1729 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1731 fr = c->time_base.den * 1000 / c->time_base.num;
1735 } else if ((fr == 29970) || (fr == 23976)) {
1740 if (norm != UNKNOWN)
1744 if (norm != UNKNOWN)
1745 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1748 if (norm == UNKNOWN) {
1749 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1750 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1751 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1755 if (!strcmp(arg, "vcd")) {
1756 opt_video_codec(o, "c:v", "mpeg1video");
1757 opt_audio_codec(o, "c:a", "mp2");
1758 parse_option(o, "f", "vcd", options);
1760 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1761 parse_option(o, "r", frame_rates[norm], options);
1762 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1764 opt_default(NULL, "b", "1150000");
1765 opt_default(NULL, "maxrate", "1150000");
1766 opt_default(NULL, "minrate", "1150000");
1767 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1769 opt_default(NULL, "b:a", "224000");
1770 parse_option(o, "ar", "44100", options);
1771 parse_option(o, "ac", "2", options);
1773 opt_default(NULL, "packetsize", "2324");
1774 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1776 /* We have to offset the PTS, so that it is consistent with the SCR.
1777 SCR starts at 36000, but the first two packs contain only padding
1778 and the first pack from the other stream, respectively, may also have
1779 been written before.
1780 So the real data starts at SCR 36000+3*1200. */
1781 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1782 } else if (!strcmp(arg, "svcd")) {
1784 opt_video_codec(o, "c:v", "mpeg2video");
1785 opt_audio_codec(o, "c:a", "mp2");
1786 parse_option(o, "f", "svcd", options);
1788 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1789 parse_option(o, "r", frame_rates[norm], options);
1790 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1792 opt_default(NULL, "b", "2040000");
1793 opt_default(NULL, "maxrate", "2516000");
1794 opt_default(NULL, "minrate", "0"); // 1145000;
1795 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1796 opt_default(NULL, "flags", "+scan_offset");
1799 opt_default(NULL, "b:a", "224000");
1800 parse_option(o, "ar", "44100", options);
1802 opt_default(NULL, "packetsize", "2324");
1804 } else if (!strcmp(arg, "dvd")) {
1806 opt_video_codec(o, "c:v", "mpeg2video");
1807 opt_audio_codec(o, "c:a", "ac3");
1808 parse_option(o, "f", "dvd", options);
1810 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1811 parse_option(o, "r", frame_rates[norm], options);
1812 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1814 opt_default(NULL, "b", "6000000");
1815 opt_default(NULL, "maxrate", "9000000");
1816 opt_default(NULL, "minrate", "0"); // 1500000;
1817 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1819 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1820 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1822 opt_default(NULL, "b:a", "448000");
1823 parse_option(o, "ar", "48000", options);
1825 } else if (!strncmp(arg, "dv", 2)) {
1827 parse_option(o, "f", "dv", options);
1829 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1830 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1831 norm == PAL ? "yuv420p" : "yuv411p", options);
1832 parse_option(o, "r", frame_rates[norm], options);
1834 parse_option(o, "ar", "48000", options);
1835 parse_option(o, "ac", "2", options);
1838 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1839 return AVERROR(EINVAL);
1844 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1846 av_free (vstats_filename);
1847 vstats_filename = av_strdup (arg);
1851 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1854 time_t today2 = time(NULL);
1855 struct tm *today = localtime(&today2);
1857 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1859 return opt_vstats_file(NULL, opt, filename);
1862 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1864 OptionsContext *o = optctx;
1865 return parse_option(o, "frames:v", arg, options);
1868 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1870 OptionsContext *o = optctx;
1871 return parse_option(o, "frames:a", arg, options);
1874 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1876 OptionsContext *o = optctx;
1877 return parse_option(o, "frames:d", arg, options);
1880 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1882 OptionsContext *o = optctx;
1883 return parse_option(o, "tag:v", arg, options);
1886 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1888 OptionsContext *o = optctx;
1889 return parse_option(o, "tag:a", arg, options);
1892 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1894 OptionsContext *o = optctx;
1895 return parse_option(o, "tag:s", arg, options);
1898 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1900 OptionsContext *o = optctx;
1901 return parse_option(o, "filter:v", arg, options);
1904 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1906 OptionsContext *o = optctx;
1907 return parse_option(o, "filter:a", arg, options);
1910 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1912 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1913 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1914 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1916 if (video_sync_method == VSYNC_AUTO)
1917 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1921 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1923 OptionsContext *o = optctx;
1924 char layout_str[32];
1927 int ret, channels, ac_str_size;
1930 layout = av_get_channel_layout(arg);
1932 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1933 return AVERROR(EINVAL);
1935 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1936 ret = opt_default(NULL, opt, layout_str);
1940 /* set 'ac' option based on channel layout */
1941 channels = av_get_channel_layout_nb_channels(layout);
1942 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1943 stream_str = strchr(opt, ':');
1944 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1945 ac_str = av_mallocz(ac_str_size);
1947 return AVERROR(ENOMEM);
1948 av_strlcpy(ac_str, "ac", 3);
1950 av_strlcat(ac_str, stream_str, ac_str_size);
1951 ret = parse_option(o, ac_str, layout_str, options);
1957 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1959 OptionsContext *o = optctx;
1960 return parse_option(o, "q:a", arg, options);
1963 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1965 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1966 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1967 return AVERROR(ENOMEM);
1968 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1969 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1970 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1971 return AVERROR(ENOMEM);
1975 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1977 uint8_t *graph_desc = read_file(arg);
1979 return AVERROR(EINVAL);
1981 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1982 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1983 return AVERROR(ENOMEM);
1984 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1985 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1989 void show_help_default(const char *opt, const char *arg)
1991 /* per-file options have at least one of those set */
1992 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1993 int show_advanced = 0, show_avoptions = 0;
1996 if (!strcmp(opt, "long"))
1998 else if (!strcmp(opt, "full"))
1999 show_advanced = show_avoptions = 1;
2001 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2006 printf("Getting help:\n"
2007 " -h -- print basic options\n"
2008 " -h long -- print more options\n"
2009 " -h full -- print all options (including all format and codec specific options, very long)\n"
2010 " See man %s for detailed description of the options.\n"
2011 "\n", program_name);
2013 show_help_options(options, "Print help / information / capabilities:",
2016 show_help_options(options, "Global options (affect whole program "
2017 "instead of just one file:",
2018 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2020 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2021 per_file | OPT_EXIT, 0);
2023 show_help_options(options, "Per-file main options:", 0,
2024 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2025 OPT_EXIT, per_file);
2027 show_help_options(options, "Advanced per-file options:",
2028 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2030 show_help_options(options, "Video options:",
2031 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2033 show_help_options(options, "Advanced Video options:",
2034 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2036 show_help_options(options, "Audio options:",
2037 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2039 show_help_options(options, "Advanced Audio options:",
2040 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2041 show_help_options(options, "Subtitle options:",
2042 OPT_SUBTITLE, 0, 0);
2045 if (show_avoptions) {
2046 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2047 show_help_children(avcodec_get_class(), flags);
2048 show_help_children(avformat_get_class(), flags);
2049 show_help_children(sws_get_class(), flags);
2050 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2054 void show_usage(void)
2056 printf("Hyper fast Audio and Video encoder\n");
2057 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2066 static const OptionGroupDef groups[] = {
2067 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2068 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2071 static int open_files(OptionGroupList *l, const char *inout,
2072 int (*open_file)(OptionsContext*, const char*))
2076 for (i = 0; i < l->nb_groups; i++) {
2077 OptionGroup *g = &l->groups[i];
2083 ret = parse_optgroup(&o, g);
2085 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2086 "%s.\n", inout, g->arg);
2090 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2091 ret = open_file(&o, g->arg);
2094 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2098 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2104 int avconv_parse_options(int argc, char **argv)
2106 OptionParseContext octx;
2110 memset(&octx, 0, sizeof(octx));
2112 /* split the commandline into an internal representation */
2113 ret = split_commandline(&octx, argc, argv, options, groups,
2114 FF_ARRAY_ELEMS(groups));
2116 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2120 /* apply global options */
2121 ret = parse_optgroup(NULL, &octx.global_opts);
2123 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2127 /* open input files */
2128 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2130 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2134 /* open output files */
2135 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2137 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2142 uninit_parse_context(&octx);
2144 av_strerror(ret, error, sizeof(error));
2145 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2150 #define OFFSET(x) offsetof(OptionsContext, x)
2151 const OptionDef options[] = {
2153 #include "cmdutils_common_opts.h"
2154 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2155 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2156 "force format", "fmt" },
2157 { "y", OPT_BOOL, { &file_overwrite },
2158 "overwrite output files" },
2159 { "n", OPT_BOOL, { &file_skip },
2160 "never overwrite output files" },
2161 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2162 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2163 "codec name", "codec" },
2164 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2165 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2166 "codec name", "codec" },
2167 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2168 OPT_OUTPUT, { .off = OFFSET(presets) },
2169 "preset name", "preset" },
2170 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2171 OPT_OUTPUT, { .func_arg = opt_map },
2172 "set input stream mapping",
2173 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2174 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2175 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2176 "set metadata information of outfile from infile",
2177 "outfile[,metadata]:infile[,metadata]" },
2178 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2179 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2180 "set chapters mapping", "input_file_index" },
2181 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2182 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2183 "record or transcode \"duration\" seconds of audio/video",
2185 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2186 "set the limit file size in bytes", "limit_size" },
2187 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2188 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2189 "set the start time offset", "time_off" },
2190 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2191 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2192 "enable/disable accurate seeking with -ss" },
2193 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2194 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2195 "set the input ts offset", "time_off" },
2196 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2197 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2198 "set the input ts scale", "scale" },
2199 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2200 "add metadata", "string=string" },
2201 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2202 OPT_OUTPUT, { .func_arg = opt_data_frames },
2203 "set the number of data frames to record", "number" },
2204 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2205 "add timings for benchmarking" },
2206 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2207 "set max runtime in seconds", "limit" },
2208 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2209 "dump each input packet" },
2210 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2211 "when dumping packets, also dump the payload" },
2212 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2213 OPT_INPUT, { .off = OFFSET(rate_emu) },
2214 "read input at native frame rate", "" },
2215 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2216 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2217 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2218 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2219 "video sync method", "" },
2220 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2221 "audio sync method", "" },
2222 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2223 "audio drift threshold", "threshold" },
2224 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2225 "copy timestamps" },
2226 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2227 "copy input stream time base when stream copying" },
2228 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2229 OPT_OUTPUT, { .off = OFFSET(shortest) },
2230 "finish encoding within shortest input" },
2231 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2232 "timestamp discontinuity delta threshold", "threshold" },
2233 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2234 "exit on error", "error" },
2235 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2236 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2237 "copy initial non-keyframes" },
2238 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2239 "set the number of frames to record", "number" },
2240 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2241 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2242 "force codec tag/fourcc", "fourcc/tag" },
2243 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2244 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2245 "use fixed quality scale (VBR)", "q" },
2246 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2247 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2248 "use fixed quality scale (VBR)", "q" },
2249 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2250 "set stream filterchain", "filter_list" },
2251 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2252 "read stream filtergraph description from a file", "filename" },
2253 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2254 "create a complex filtergraph", "graph_description" },
2255 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2256 "read complex filtergraph description from a file", "filename" },
2257 { "stats", OPT_BOOL, { &print_stats },
2258 "print progress report during encoding", },
2259 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2260 OPT_OUTPUT, { .func_arg = opt_attach },
2261 "add an attachment to the output file", "filename" },
2262 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2263 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2264 "extract an attachment into a file", "filename" },
2267 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2268 "set the number of video frames to record", "number" },
2269 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2270 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2271 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2272 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2273 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2274 "set frame size (WxH or abbreviation)", "size" },
2275 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2276 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2277 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2278 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2279 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2280 "set pixel format", "format" },
2281 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2283 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2284 "discard threshold", "n" },
2285 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2286 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2287 "rate control override for specific intervals", "override" },
2288 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2289 OPT_OUTPUT, { .func_arg = opt_video_codec },
2290 "force video codec ('copy' to copy stream)", "codec" },
2291 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2292 "select the pass number (1 or 2)", "n" },
2293 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2294 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2295 "select two pass log file name prefix", "prefix" },
2296 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2297 "dump video coding statistics to file" },
2298 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2299 "dump video coding statistics to file", "file" },
2300 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2301 "video filters", "filter list" },
2302 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2303 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2304 "specify intra matrix coeffs", "matrix" },
2305 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2306 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2307 "specify inter matrix coeffs", "matrix" },
2308 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2309 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2310 "top=1/bottom=0/auto=-1 field first", "" },
2311 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2312 "intra_dc_precision", "precision" },
2313 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2314 OPT_OUTPUT, { .func_arg = opt_video_tag },
2315 "force video tag/fourcc", "fourcc/tag" },
2316 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2317 "show QP histogram" },
2318 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2319 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2320 "force the selected framerate, disable the best supported framerate selection" },
2321 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2322 OPT_OUTPUT, { .func_arg = opt_streamid },
2323 "set the value of an outfile streamid", "streamIndex:value" },
2324 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2325 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2326 "force key frames at specified timestamps", "timestamps" },
2327 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2328 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2329 "use HW accelerated decoding", "hwaccel name" },
2330 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2331 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2332 "select a device for HW acceleration" "devicename" },
2335 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2336 "set the number of audio frames to record", "number" },
2337 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2338 "set audio quality (codec-specific)", "quality", },
2339 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2340 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2341 "set audio sampling rate (in Hz)", "rate" },
2342 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2343 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2344 "set number of audio channels", "channels" },
2345 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2347 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2348 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2349 "force audio codec ('copy' to copy stream)", "codec" },
2350 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2351 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2352 "force audio tag/fourcc", "fourcc/tag" },
2353 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2354 "change audio volume (256=normal)" , "volume" },
2355 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2356 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2357 "set sample format", "format" },
2358 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2359 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2360 "set channel layout", "layout" },
2361 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2362 "audio filters", "filter list" },
2364 /* subtitle options */
2365 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2366 "disable subtitle" },
2367 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2368 "force subtitle codec ('copy' to copy stream)", "codec" },
2369 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2370 , "force subtitle tag/fourcc", "fourcc/tag" },
2373 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2376 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2377 "set the maximum demux-decode delay", "seconds" },
2378 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2379 "set the initial demux-decode delay", "seconds" },
2381 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2382 "A comma-separated list of bitstream filters", "bitstream_filters" },
2384 /* data codec support */
2385 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2386 "force data codec ('copy' to copy stream)", "codec" },