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 },
61 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
64 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
69 char *vstats_filename;
71 float audio_drift_threshold = 0.1;
72 float dts_delta_threshold = 10;
74 int audio_volume = 256;
75 int audio_sync_method = 0;
76 int video_sync_method = VSYNC_AUTO;
82 int exit_on_error = 0;
86 static int file_overwrite = 0;
87 static int file_skip = 0;
88 static int video_discard = 0;
89 static int intra_dc_precision = 8;
90 static int using_stdin = 0;
91 static int input_sync;
93 static void uninit_options(OptionsContext *o)
95 const OptionDef *po = options;
98 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
100 void *dst = (uint8_t*)o + po->u.off;
102 if (po->flags & OPT_SPEC) {
103 SpecifierOpt **so = dst;
104 int i, *count = (int*)(so + 1);
105 for (i = 0; i < *count; i++) {
106 av_freep(&(*so)[i].specifier);
107 if (po->flags & OPT_STRING)
108 av_freep(&(*so)[i].u.str);
112 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
117 for (i = 0; i < o->nb_stream_maps; i++)
118 av_freep(&o->stream_maps[i].linklabel);
119 av_freep(&o->stream_maps);
120 av_freep(&o->meta_data_maps);
121 av_freep(&o->streamid_map);
124 static void init_options(OptionsContext *o)
126 memset(o, 0, sizeof(*o));
128 o->mux_max_delay = 0.7;
129 o->start_time = AV_NOPTS_VALUE;
130 o->recording_time = INT64_MAX;
131 o->limit_filesize = UINT64_MAX;
132 o->chapters_input_file = INT_MAX;
133 o->accurate_seek = 1;
136 /* return a copy of the input with the stream specifiers removed from the keys */
137 static AVDictionary *strip_specifiers(AVDictionary *dict)
139 AVDictionaryEntry *e = NULL;
140 AVDictionary *ret = NULL;
142 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
143 char *p = strchr(e->key, ':');
147 av_dict_set(&ret, e->key, e->value, 0);
154 static double parse_frame_aspect_ratio(const char *arg)
161 p = strchr(arg, ':');
163 x = strtol(arg, &end, 10);
165 y = strtol(end + 1, &end, 10);
167 ar = (double)x / (double)y;
169 ar = strtod(arg, NULL);
172 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 return parse_option(o, "codec:a", arg, options);
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
186 OptionsContext *o = optctx;
187 return parse_option(o, "codec:v", arg, options);
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
192 OptionsContext *o = optctx;
193 return parse_option(o, "codec:s", arg, options);
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:d", arg, options);
202 static int opt_map(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
206 int i, negative = 0, file_idx;
207 int sync_file_idx = -1, sync_stream_idx;
215 map = av_strdup(arg);
217 return AVERROR(ENOMEM);
219 /* parse sync stream first, just pick first matching stream */
220 if (sync = strchr(map, ',')) {
222 sync_file_idx = strtol(sync + 1, &sync, 0);
223 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
224 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
229 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
230 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
231 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
235 if (i == input_files[sync_file_idx]->nb_streams) {
236 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
237 "match any streams.\n", arg);
244 /* this mapping refers to lavfi output */
245 const char *c = map + 1;
246 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
247 m = &o->stream_maps[o->nb_stream_maps - 1];
248 m->linklabel = av_get_token(&c, "]");
250 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
254 file_idx = strtol(map, &p, 0);
255 if (file_idx >= nb_input_files || file_idx < 0) {
256 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
260 /* disable some already defined maps */
261 for (i = 0; i < o->nb_stream_maps; i++) {
262 m = &o->stream_maps[i];
263 if (file_idx == m->file_index &&
264 check_stream_specifier(input_files[m->file_index]->ctx,
265 input_files[m->file_index]->ctx->streams[m->stream_index],
266 *p == ':' ? p + 1 : p) > 0)
270 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
271 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
272 *p == ':' ? p + 1 : p) <= 0)
274 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
275 m = &o->stream_maps[o->nb_stream_maps - 1];
277 m->file_index = file_idx;
280 if (sync_file_idx >= 0) {
281 m->sync_file_index = sync_file_idx;
282 m->sync_stream_index = sync_stream_idx;
284 m->sync_file_index = file_idx;
285 m->sync_stream_index = i;
291 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
299 static int opt_attach(void *optctx, const char *opt, const char *arg)
301 OptionsContext *o = optctx;
302 GROW_ARRAY(o->attachments, o->nb_attachments);
303 o->attachments[o->nb_attachments - 1] = arg;
308 * Parse a metadata specifier passed as 'arg' parameter.
309 * @param arg metadata string to parse
310 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
311 * @param index for type c/p, chapter/program index is written here
312 * @param stream_spec for type s, the stream specifier is written here
314 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
322 if (*(++arg) && *arg != ':') {
323 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
326 *stream_spec = *arg == ':' ? arg + 1 : "";
331 *index = strtol(++arg, NULL, 0);
334 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
341 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
343 AVDictionary **meta_in = NULL;
344 AVDictionary **meta_out;
346 char type_in, type_out;
347 const char *istream_spec = NULL, *ostream_spec = NULL;
348 int idx_in = 0, idx_out = 0;
350 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
351 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
353 if (type_in == 'g' || type_out == 'g')
354 o->metadata_global_manual = 1;
355 if (type_in == 's' || type_out == 's')
356 o->metadata_streams_manual = 1;
357 if (type_in == 'c' || type_out == 'c')
358 o->metadata_chapters_manual = 1;
360 /* ic is NULL when just disabling automatic mappings */
364 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
365 if ((index) < 0 || (index) >= (nb_elems)) {\
366 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
371 #define SET_DICT(type, meta, context, index)\
374 meta = &context->metadata;\
377 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
378 meta = &context->chapters[index]->metadata;\
381 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
382 meta = &context->programs[index]->metadata;\
385 break; /* handled separately below */ \
386 default: av_assert0(0);\
389 SET_DICT(type_in, meta_in, ic, idx_in);
390 SET_DICT(type_out, meta_out, oc, idx_out);
392 /* for input streams choose first matching stream */
393 if (type_in == 's') {
394 for (i = 0; i < ic->nb_streams; i++) {
395 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
396 meta_in = &ic->streams[i]->metadata;
402 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
407 if (type_out == 's') {
408 for (i = 0; i < oc->nb_streams; i++) {
409 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
410 meta_out = &oc->streams[i]->metadata;
411 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
416 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
421 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
423 const AVCodecDescriptor *desc;
424 const char *codec_string = encoder ? "encoder" : "decoder";
428 avcodec_find_encoder_by_name(name) :
429 avcodec_find_decoder_by_name(name);
431 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
432 codec = encoder ? avcodec_find_encoder(desc->id) :
433 avcodec_find_decoder(desc->id);
435 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
436 codec_string, codec->name, desc->name);
440 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
443 if (codec->type != type) {
444 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
450 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
452 char *codec_name = NULL;
454 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
456 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
457 st->codec->codec_id = codec->id;
460 return avcodec_find_decoder(st->codec->codec_id);
463 /* Add all the streams from the given input file to the global
464 * list of input streams. */
465 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
469 for (i = 0; i < ic->nb_streams; i++) {
470 AVStream *st = ic->streams[i];
471 AVCodecContext *dec = st->codec;
472 InputStream *ist = av_mallocz(sizeof(*ist));
473 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
474 char *codec_tag = NULL;
480 GROW_ARRAY(input_streams, nb_input_streams);
481 input_streams[nb_input_streams - 1] = ist;
484 ist->file_index = nb_input_files;
486 st->discard = AVDISCARD_ALL;
489 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
492 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
494 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
496 uint32_t tag = strtol(codec_tag, &next, 0);
498 tag = AV_RL32(codec_tag);
499 st->codec->codec_tag = tag;
502 ist->dec = choose_decoder(o, ic, st);
503 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
505 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
507 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
511 ret = avcodec_copy_context(ist->dec_ctx, dec);
513 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
517 switch (dec->codec_type) {
518 case AVMEDIA_TYPE_VIDEO:
519 ist->resample_height = ist->dec_ctx->height;
520 ist->resample_width = ist->dec_ctx->width;
521 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
523 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
524 if (framerate && av_parse_video_rate(&ist->framerate,
526 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
531 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
533 if (!strcmp(hwaccel, "none"))
534 ist->hwaccel_id = HWACCEL_NONE;
535 else if (!strcmp(hwaccel, "auto"))
536 ist->hwaccel_id = HWACCEL_AUTO;
539 for (i = 0; hwaccels[i].name; i++) {
540 if (!strcmp(hwaccels[i].name, hwaccel)) {
541 ist->hwaccel_id = hwaccels[i].id;
546 if (!ist->hwaccel_id) {
547 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
549 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
550 for (i = 0; hwaccels[i].name; i++)
551 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
552 av_log(NULL, AV_LOG_FATAL, "\n");
558 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
559 if (hwaccel_device) {
560 ist->hwaccel_device = av_strdup(hwaccel_device);
561 if (!ist->hwaccel_device)
564 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
567 case AVMEDIA_TYPE_AUDIO:
568 guess_input_channel_layout(ist);
570 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
571 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
572 ist->resample_channels = ist->dec_ctx->channels;
573 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
576 case AVMEDIA_TYPE_DATA:
577 case AVMEDIA_TYPE_SUBTITLE:
578 case AVMEDIA_TYPE_ATTACHMENT:
579 case AVMEDIA_TYPE_UNKNOWN:
587 static void assert_file_overwrite(const char *filename)
589 if (file_overwrite && file_skip) {
590 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
594 if (!file_overwrite &&
595 (!strchr(filename, ':') || filename[1] == ':' ||
596 av_strstart(filename, "file:", NULL))) {
597 if (avio_check(filename, 0) == 0) {
598 if (!using_stdin && !file_skip) {
599 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
602 fprintf(stderr, "Not overwriting - exiting\n");
607 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
614 static void dump_attachment(AVStream *st, const char *filename)
617 AVIOContext *out = NULL;
618 AVDictionaryEntry *e;
620 if (!st->codec->extradata_size) {
621 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
622 nb_input_files - 1, st->index);
625 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
628 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
629 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
633 assert_file_overwrite(filename);
635 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
636 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
641 avio_write(out, st->codec->extradata, st->codec->extradata_size);
646 static int open_input_file(OptionsContext *o, const char *filename)
650 AVInputFormat *file_iformat = NULL;
655 AVDictionary *unused_opts = NULL;
656 AVDictionaryEntry *e = NULL;
657 int orig_nb_streams; // number of streams before avformat_find_stream_info
660 if (!(file_iformat = av_find_input_format(o->format))) {
661 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
666 if (!strcmp(filename, "-"))
669 using_stdin |= !strncmp(filename, "pipe:", 5) ||
670 !strcmp(filename, "/dev/stdin");
672 /* get default parameters from command line */
673 ic = avformat_alloc_context();
675 print_error(filename, AVERROR(ENOMEM));
678 if (o->nb_audio_sample_rate) {
679 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
680 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
682 if (o->nb_audio_channels) {
683 /* because we set audio_channels based on both the "ac" and
684 * "channel_layout" options, we need to check that the specified
685 * demuxer actually has the "channels" option before setting it */
686 if (file_iformat && file_iformat->priv_class &&
687 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
688 AV_OPT_SEARCH_FAKE_OBJ)) {
689 snprintf(buf, sizeof(buf), "%d",
690 o->audio_channels[o->nb_audio_channels - 1].u.i);
691 av_dict_set(&o->g->format_opts, "channels", buf, 0);
694 if (o->nb_frame_rates) {
695 /* set the format-level framerate option;
696 * this is important for video grabbers, e.g. x11 */
697 if (file_iformat && file_iformat->priv_class &&
698 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
699 AV_OPT_SEARCH_FAKE_OBJ)) {
700 av_dict_set(&o->g->format_opts, "framerate",
701 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
704 if (o->nb_frame_sizes) {
705 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
707 if (o->nb_frame_pix_fmts)
708 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
710 ic->flags |= AVFMT_FLAG_NONBLOCK;
711 ic->interrupt_callback = int_cb;
713 /* open the input file with generic libav function */
714 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
716 print_error(filename, err);
719 assert_avoptions(o->g->format_opts);
721 /* apply forced codec ids */
722 for (i = 0; i < ic->nb_streams; i++)
723 choose_decoder(o, ic, ic->streams[i]);
725 /* Set AVCodecContext options for avformat_find_stream_info */
726 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
727 orig_nb_streams = ic->nb_streams;
729 /* If not enough info to get the stream parameters, we decode the
730 first frames to get it. (used in mpeg case for example) */
731 ret = avformat_find_stream_info(ic, opts);
733 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
734 avformat_close_input(&ic);
738 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
739 /* add the stream start time */
740 if (ic->start_time != AV_NOPTS_VALUE)
741 timestamp += ic->start_time;
743 /* if seeking requested, we execute it */
744 if (o->start_time != AV_NOPTS_VALUE) {
745 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
747 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
748 filename, (double)timestamp / AV_TIME_BASE);
752 /* update the current parameters so that they match the one of the input stream */
753 add_input_streams(o, ic);
755 /* dump the file content */
756 av_dump_format(ic, nb_input_files, filename, 0);
758 GROW_ARRAY(input_files, nb_input_files);
759 f = av_mallocz(sizeof(*f));
762 input_files[nb_input_files - 1] = f;
765 f->ist_index = nb_input_streams - ic->nb_streams;
766 f->start_time = o->start_time;
767 f->recording_time = o->recording_time;
768 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
769 f->nb_streams = ic->nb_streams;
770 f->rate_emu = o->rate_emu;
771 f->accurate_seek = o->accurate_seek;
773 /* check if all codec options have been used */
774 unused_opts = strip_specifiers(o->g->codec_opts);
775 for (i = f->ist_index; i < nb_input_streams; i++) {
777 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
778 AV_DICT_IGNORE_SUFFIX)))
779 av_dict_set(&unused_opts, e->key, NULL, 0);
783 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
784 const AVClass *class = avcodec_get_class();
785 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
786 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
789 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
790 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
791 "input file #%d (%s) is not a decoding option.\n", e->key,
792 option->help ? option->help : "", nb_input_files - 1,
797 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
798 "input file #%d (%s) has not been used for any stream. The most "
799 "likely reason is either wrong type (e.g. a video option with "
800 "no video streams) or that it is a private option of some decoder "
801 "which was not actually used for any stream.\n", e->key,
802 option->help ? option->help : "", nb_input_files - 1, filename);
804 av_dict_free(&unused_opts);
806 for (i = 0; i < o->nb_dump_attachment; i++) {
809 for (j = 0; j < ic->nb_streams; j++) {
810 AVStream *st = ic->streams[j];
812 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
813 dump_attachment(st, o->dump_attachment[i].u.str);
817 for (i = 0; i < orig_nb_streams; i++)
818 av_dict_free(&opts[i]);
824 static uint8_t *get_line(AVIOContext *s)
830 if (avio_open_dyn_buf(&line) < 0) {
831 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
835 while ((c = avio_r8(s)) && c != '\n')
838 avio_close_dyn_buf(line, &buf);
843 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
847 const char *base[3] = { getenv("AVCONV_DATADIR"),
852 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
856 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
857 i != 1 ? "" : "/.avconv", codec_name, preset_name);
858 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
861 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
862 i != 1 ? "" : "/.avconv", preset_name);
863 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
869 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
871 char *codec_name = NULL;
873 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
875 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
876 NULL, ost->st->codec->codec_type);
877 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
878 } else if (!strcmp(codec_name, "copy"))
879 ost->stream_copy = 1;
881 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
882 ost->st->codec->codec_id = ost->enc->id;
886 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
889 AVStream *st = avformat_new_stream(oc, NULL);
890 int idx = oc->nb_streams - 1, ret = 0;
891 char *bsf = NULL, *next, *codec_tag = NULL;
892 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
896 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
900 if (oc->nb_streams - 1 < o->nb_streamid_map)
901 st->id = o->streamid_map[oc->nb_streams - 1];
903 GROW_ARRAY(output_streams, nb_output_streams);
904 if (!(ost = av_mallocz(sizeof(*ost))))
906 output_streams[nb_output_streams - 1] = ost;
908 ost->file_index = nb_output_files - 1;
911 st->codec->codec_type = type;
912 choose_encoder(o, oc, ost);
914 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
916 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
919 ost->enc_ctx->codec_type = type;
922 AVIOContext *s = NULL;
923 char *buf = NULL, *arg = NULL, *preset = NULL;
925 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
927 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
928 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
931 if (!buf[0] || buf[0] == '#') {
935 if (!(arg = strchr(buf, '='))) {
936 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
940 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
942 } while (!s->eof_reached);
946 av_log(NULL, AV_LOG_FATAL,
947 "Preset %s specified for stream %d:%d, but could not be opened.\n",
948 preset, ost->file_index, ost->index);
952 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
955 ost->max_frames = INT64_MAX;
956 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
958 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
960 if (next = strchr(bsf, ','))
962 if (!(bsfc = av_bitstream_filter_init(bsf))) {
963 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
967 bsfc_prev->next = bsfc;
969 ost->bitstream_filters = bsfc;
975 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
977 uint32_t tag = strtol(codec_tag, &next, 0);
979 tag = AV_RL32(codec_tag);
980 ost->enc_ctx->codec_tag = tag;
983 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
985 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
986 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
989 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
990 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
992 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
994 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
996 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
997 ost->last_mux_dts = AV_NOPTS_VALUE;
1002 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1005 const char *p = str;
1012 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1019 /* read file contents into a string */
1020 static uint8_t *read_file(const char *filename)
1022 AVIOContext *pb = NULL;
1023 AVIOContext *dyn_buf = NULL;
1024 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1025 uint8_t buf[1024], *str;
1028 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1032 ret = avio_open_dyn_buf(&dyn_buf);
1037 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1038 avio_write(dyn_buf, buf, ret);
1039 avio_w8(dyn_buf, 0);
1042 ret = avio_close_dyn_buf(dyn_buf, &str);
1048 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1051 AVStream *st = ost->st;
1052 char *filter = NULL, *filter_script = NULL;
1054 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1055 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1057 if (filter_script && filter) {
1058 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1059 "output stream #%d:%d.\n", nb_output_files, st->index);
1064 return read_file(filter_script);
1066 return av_strdup(filter);
1068 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1072 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1076 AVCodecContext *video_enc;
1077 char *frame_aspect_ratio = NULL;
1079 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1081 video_enc = ost->enc_ctx;
1083 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1084 if (frame_aspect_ratio)
1085 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1087 if (!ost->stream_copy) {
1088 const char *p = NULL;
1089 char *frame_rate = NULL, *frame_size = NULL;
1090 char *frame_pix_fmt = NULL;
1091 char *intra_matrix = NULL, *inter_matrix = NULL;
1095 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1096 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1097 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1101 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1102 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1103 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1107 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1108 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1109 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1112 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1114 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1116 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1117 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1120 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1122 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1124 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1125 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1128 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1131 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1132 for (i = 0; p; i++) {
1134 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1136 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1139 video_enc->rc_override =
1140 av_realloc(video_enc->rc_override,
1141 sizeof(RcOverride) * (i + 1));
1142 if (!video_enc->rc_override) {
1143 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1146 video_enc->rc_override[i].start_frame = start;
1147 video_enc->rc_override[i].end_frame = end;
1149 video_enc->rc_override[i].qscale = q;
1150 video_enc->rc_override[i].quality_factor = 1.0;
1153 video_enc->rc_override[i].qscale = 0;
1154 video_enc->rc_override[i].quality_factor = -q/100.0;
1159 video_enc->rc_override_count = i;
1160 video_enc->intra_dc_precision = intra_dc_precision - 8;
1163 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1166 video_enc->flags |= CODEC_FLAG_PASS1;
1168 video_enc->flags |= CODEC_FLAG_PASS2;
1172 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1173 if (ost->logfile_prefix &&
1174 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1177 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1178 if (ost->forced_keyframes)
1179 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1181 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1183 ost->top_field_first = -1;
1184 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1187 ost->avfilter = get_ost_filters(o, oc, ost);
1191 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1197 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1201 AVCodecContext *audio_enc;
1203 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1206 audio_enc = ost->enc_ctx;
1207 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1209 if (!ost->stream_copy) {
1210 char *sample_fmt = NULL;
1212 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1214 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1216 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1217 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1221 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1223 ost->avfilter = get_ost_filters(o, oc, ost);
1231 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1235 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1236 if (!ost->stream_copy) {
1237 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1244 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1246 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1247 ost->stream_copy = 1;
1252 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1255 AVCodecContext *subtitle_enc;
1257 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1258 subtitle_enc = ost->enc_ctx;
1260 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1265 /* arg format is "output-stream-index:streamid-value". */
1266 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1268 OptionsContext *o = optctx;
1273 av_strlcpy(idx_str, arg, sizeof(idx_str));
1274 p = strchr(idx_str, ':');
1276 av_log(NULL, AV_LOG_FATAL,
1277 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1282 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1283 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1284 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1288 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1290 AVFormatContext *is = ifile->ctx;
1291 AVFormatContext *os = ofile->ctx;
1295 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1297 return AVERROR(ENOMEM);
1300 for (i = 0; i < is->nb_chapters; i++) {
1301 AVChapter *in_ch = is->chapters[i], *out_ch;
1302 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1303 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1304 AV_TIME_BASE_Q, in_ch->time_base);
1305 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1306 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1309 if (in_ch->end < ts_off)
1311 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1314 out_ch = av_mallocz(sizeof(AVChapter));
1316 return AVERROR(ENOMEM);
1318 out_ch->id = in_ch->id;
1319 out_ch->time_base = in_ch->time_base;
1320 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1321 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1324 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1326 os->chapters[os->nb_chapters++] = out_ch;
1331 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1332 AVFormatContext *oc)
1336 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1337 ofilter->out_tmp->pad_idx)) {
1338 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1339 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1341 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1346 ost->source_index = -1;
1347 ost->filter = ofilter;
1351 if (ost->stream_copy) {
1352 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1353 "which is fed from a complex filtergraph. Filtering and streamcopy "
1354 "cannot be used together.\n", ost->file_index, ost->index);
1358 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1359 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1362 avfilter_inout_free(&ofilter->out_tmp);
1365 static int configure_complex_filters(void)
1369 for (i = 0; i < nb_filtergraphs; i++)
1370 if (!filtergraphs[i]->graph &&
1371 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1376 static int open_output_file(OptionsContext *o, const char *filename)
1378 AVFormatContext *oc;
1380 AVOutputFormat *file_oformat;
1384 AVDictionary *unused_opts = NULL;
1385 AVDictionaryEntry *e = NULL;
1387 if (configure_complex_filters() < 0) {
1388 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1392 GROW_ARRAY(output_files, nb_output_files);
1393 of = av_mallocz(sizeof(*of));
1396 output_files[nb_output_files - 1] = of;
1398 of->ost_index = nb_output_streams;
1399 of->recording_time = o->recording_time;
1400 of->start_time = o->start_time;
1401 of->limit_filesize = o->limit_filesize;
1402 of->shortest = o->shortest;
1403 av_dict_copy(&of->opts, o->g->format_opts, 0);
1405 if (!strcmp(filename, "-"))
1408 oc = avformat_alloc_context();
1410 print_error(filename, AVERROR(ENOMEM));
1414 if (o->recording_time != INT64_MAX)
1415 oc->duration = o->recording_time;
1418 file_oformat = av_guess_format(o->format, NULL, NULL);
1419 if (!file_oformat) {
1420 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1424 file_oformat = av_guess_format(NULL, filename, NULL);
1425 if (!file_oformat) {
1426 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1432 oc->oformat = file_oformat;
1433 oc->interrupt_callback = int_cb;
1434 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1436 /* create streams for all unlabeled output pads */
1437 for (i = 0; i < nb_filtergraphs; i++) {
1438 FilterGraph *fg = filtergraphs[i];
1439 for (j = 0; j < fg->nb_outputs; j++) {
1440 OutputFilter *ofilter = fg->outputs[j];
1442 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1445 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1446 ofilter->out_tmp->pad_idx)) {
1447 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1448 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1449 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1451 init_output_filter(ofilter, o, oc);
1455 if (!o->nb_stream_maps) {
1456 /* pick the "best" stream of each type */
1457 #define NEW_STREAM(type, index)\
1459 ost = new_ ## type ## _stream(o, oc);\
1460 ost->source_index = index;\
1461 ost->sync_ist = input_streams[index];\
1462 input_streams[index]->discard = 0;\
1463 input_streams[index]->st->discard = AVDISCARD_NONE;\
1466 /* video: highest resolution */
1467 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1468 int area = 0, idx = -1;
1469 for (i = 0; i < nb_input_streams; i++) {
1470 ist = input_streams[i];
1471 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1472 ist->st->codec->width * ist->st->codec->height > area) {
1473 area = ist->st->codec->width * ist->st->codec->height;
1477 NEW_STREAM(video, idx);
1480 /* audio: most channels */
1481 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1482 int channels = 0, idx = -1;
1483 for (i = 0; i < nb_input_streams; i++) {
1484 ist = input_streams[i];
1485 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1486 ist->st->codec->channels > channels) {
1487 channels = ist->st->codec->channels;
1491 NEW_STREAM(audio, idx);
1494 /* subtitles: pick first */
1495 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1496 for (i = 0; i < nb_input_streams; i++)
1497 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1498 NEW_STREAM(subtitle, i);
1502 /* do something with data? */
1504 for (i = 0; i < o->nb_stream_maps; i++) {
1505 StreamMap *map = &o->stream_maps[i];
1510 if (map->linklabel) {
1512 OutputFilter *ofilter = NULL;
1515 for (j = 0; j < nb_filtergraphs; j++) {
1516 fg = filtergraphs[j];
1517 for (k = 0; k < fg->nb_outputs; k++) {
1518 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1519 if (out && !strcmp(out->name, map->linklabel)) {
1520 ofilter = fg->outputs[k];
1527 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1528 "in any defined filter graph.\n", map->linklabel);
1531 init_output_filter(ofilter, o, oc);
1533 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1534 switch (ist->st->codec->codec_type) {
1535 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1536 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1537 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1538 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1539 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1541 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1542 map->file_index, map->stream_index);
1546 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1547 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1548 map->sync_stream_index];
1550 ist->st->discard = AVDISCARD_NONE;
1555 /* handle attached files */
1556 for (i = 0; i < o->nb_attachments; i++) {
1558 uint8_t *attachment;
1562 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1563 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1567 if ((len = avio_size(pb)) <= 0) {
1568 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1572 if (!(attachment = av_malloc(len))) {
1573 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1577 avio_read(pb, attachment, len);
1579 ost = new_attachment_stream(o, oc);
1580 ost->stream_copy = 0;
1581 ost->source_index = -1;
1582 ost->attachment_filename = o->attachments[i];
1583 ost->st->codec->extradata = attachment;
1584 ost->st->codec->extradata_size = len;
1586 p = strrchr(o->attachments[i], '/');
1587 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1591 /* check if all codec options have been used */
1592 unused_opts = strip_specifiers(o->g->codec_opts);
1593 for (i = of->ost_index; i < nb_output_streams; i++) {
1595 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1596 AV_DICT_IGNORE_SUFFIX)))
1597 av_dict_set(&unused_opts, e->key, NULL, 0);
1601 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1602 const AVClass *class = avcodec_get_class();
1603 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1604 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1607 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1608 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1609 "output file #%d (%s) is not an encoding option.\n", e->key,
1610 option->help ? option->help : "", nb_output_files - 1,
1615 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1616 "output file #%d (%s) has not been used for any stream. The most "
1617 "likely reason is either wrong type (e.g. a video option with "
1618 "no video streams) or that it is a private option of some encoder "
1619 "which was not actually used for any stream.\n", e->key,
1620 option->help ? option->help : "", nb_output_files - 1, filename);
1622 av_dict_free(&unused_opts);
1624 /* check filename in case of an image number is expected */
1625 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1626 if (!av_filename_number_test(oc->filename)) {
1627 print_error(oc->filename, AVERROR(EINVAL));
1632 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1633 /* test if it already exists to avoid losing precious files */
1634 assert_file_overwrite(filename);
1637 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1638 &oc->interrupt_callback,
1640 print_error(filename, err);
1645 if (o->mux_preload) {
1647 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1648 av_dict_set(&of->opts, "preload", buf, 0);
1650 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1651 oc->flags |= AVFMT_FLAG_NONBLOCK;
1654 for (i = 0; i < o->nb_metadata_map; i++) {
1656 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1658 if (in_file_index >= nb_input_files) {
1659 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1662 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1663 in_file_index >= 0 ?
1664 input_files[in_file_index]->ctx : NULL, o);
1668 if (o->chapters_input_file >= nb_input_files) {
1669 if (o->chapters_input_file == INT_MAX) {
1670 /* copy chapters from the first input file that has them*/
1671 o->chapters_input_file = -1;
1672 for (i = 0; i < nb_input_files; i++)
1673 if (input_files[i]->ctx->nb_chapters) {
1674 o->chapters_input_file = i;
1678 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1679 o->chapters_input_file);
1683 if (o->chapters_input_file >= 0)
1684 copy_chapters(input_files[o->chapters_input_file], of,
1685 !o->metadata_chapters_manual);
1687 /* copy global metadata by default */
1688 if (!o->metadata_global_manual && nb_input_files)
1689 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1690 AV_DICT_DONT_OVERWRITE);
1691 if (!o->metadata_streams_manual)
1692 for (i = of->ost_index; i < nb_output_streams; i++) {
1694 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1696 ist = input_streams[output_streams[i]->source_index];
1697 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1700 /* process manually set metadata */
1701 for (i = 0; i < o->nb_metadata; i++) {
1704 const char *stream_spec;
1705 int index = 0, j, ret;
1707 val = strchr(o->metadata[i].u.str, '=');
1709 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1710 o->metadata[i].u.str);
1715 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1717 for (j = 0; j < oc->nb_streams; j++) {
1718 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1719 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1730 if (index < 0 || index >= oc->nb_chapters) {
1731 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1734 m = &oc->chapters[index]->metadata;
1737 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1740 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1747 static int opt_target(void *optctx, const char *opt, const char *arg)
1749 OptionsContext *o = optctx;
1750 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1751 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1753 if (!strncmp(arg, "pal-", 4)) {
1756 } else if (!strncmp(arg, "ntsc-", 5)) {
1759 } else if (!strncmp(arg, "film-", 5)) {
1763 /* Try to determine PAL/NTSC by peeking in the input files */
1764 if (nb_input_files) {
1766 for (j = 0; j < nb_input_files; j++) {
1767 for (i = 0; i < input_files[j]->nb_streams; i++) {
1768 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1769 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1772 fr = c->time_base.den * 1000 / c->time_base.num;
1776 } else if ((fr == 29970) || (fr == 23976)) {
1781 if (norm != UNKNOWN)
1785 if (norm != UNKNOWN)
1786 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1789 if (norm == UNKNOWN) {
1790 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1791 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1792 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1796 if (!strcmp(arg, "vcd")) {
1797 opt_video_codec(o, "c:v", "mpeg1video");
1798 opt_audio_codec(o, "c:a", "mp2");
1799 parse_option(o, "f", "vcd", options);
1801 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1802 parse_option(o, "r", frame_rates[norm], options);
1803 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1805 opt_default(NULL, "b", "1150000");
1806 opt_default(NULL, "maxrate", "1150000");
1807 opt_default(NULL, "minrate", "1150000");
1808 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1810 opt_default(NULL, "b:a", "224000");
1811 parse_option(o, "ar", "44100", options);
1812 parse_option(o, "ac", "2", options);
1814 opt_default(NULL, "packetsize", "2324");
1815 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1817 /* We have to offset the PTS, so that it is consistent with the SCR.
1818 SCR starts at 36000, but the first two packs contain only padding
1819 and the first pack from the other stream, respectively, may also have
1820 been written before.
1821 So the real data starts at SCR 36000+3*1200. */
1822 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1823 } else if (!strcmp(arg, "svcd")) {
1825 opt_video_codec(o, "c:v", "mpeg2video");
1826 opt_audio_codec(o, "c:a", "mp2");
1827 parse_option(o, "f", "svcd", options);
1829 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1830 parse_option(o, "r", frame_rates[norm], options);
1831 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1833 opt_default(NULL, "b", "2040000");
1834 opt_default(NULL, "maxrate", "2516000");
1835 opt_default(NULL, "minrate", "0"); // 1145000;
1836 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1837 opt_default(NULL, "scan_offset", "1");
1840 opt_default(NULL, "b:a", "224000");
1841 parse_option(o, "ar", "44100", options);
1843 opt_default(NULL, "packetsize", "2324");
1845 } else if (!strcmp(arg, "dvd")) {
1847 opt_video_codec(o, "c:v", "mpeg2video");
1848 opt_audio_codec(o, "c:a", "ac3");
1849 parse_option(o, "f", "dvd", options);
1851 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1852 parse_option(o, "r", frame_rates[norm], options);
1853 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1855 opt_default(NULL, "b", "6000000");
1856 opt_default(NULL, "maxrate", "9000000");
1857 opt_default(NULL, "minrate", "0"); // 1500000;
1858 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1860 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1861 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1863 opt_default(NULL, "b:a", "448000");
1864 parse_option(o, "ar", "48000", options);
1866 } else if (!strncmp(arg, "dv", 2)) {
1868 parse_option(o, "f", "dv", options);
1870 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1871 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1872 norm == PAL ? "yuv420p" : "yuv411p", options);
1873 parse_option(o, "r", frame_rates[norm], options);
1875 parse_option(o, "ar", "48000", options);
1876 parse_option(o, "ac", "2", options);
1879 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1880 return AVERROR(EINVAL);
1883 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1884 av_dict_copy(&o->g->format_opts, format_opts, 0);
1889 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1891 av_free (vstats_filename);
1892 vstats_filename = av_strdup (arg);
1896 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1899 time_t today2 = time(NULL);
1900 struct tm *today = localtime(&today2);
1902 if (!today) { // maybe tomorrow
1903 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1907 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1909 return opt_vstats_file(NULL, opt, filename);
1912 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1914 OptionsContext *o = optctx;
1915 return parse_option(o, "frames:v", arg, options);
1918 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1920 OptionsContext *o = optctx;
1921 return parse_option(o, "frames:a", arg, options);
1924 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1926 OptionsContext *o = optctx;
1927 return parse_option(o, "frames:d", arg, options);
1930 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1932 OptionsContext *o = optctx;
1933 return parse_option(o, "tag:v", arg, options);
1936 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1938 OptionsContext *o = optctx;
1939 return parse_option(o, "tag:a", arg, options);
1942 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1944 OptionsContext *o = optctx;
1945 return parse_option(o, "tag:s", arg, options);
1948 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1950 OptionsContext *o = optctx;
1951 return parse_option(o, "filter:v", arg, options);
1954 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1956 OptionsContext *o = optctx;
1957 return parse_option(o, "filter:a", arg, options);
1960 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1962 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1963 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1964 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1966 if (video_sync_method == VSYNC_AUTO)
1967 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1971 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1973 OptionsContext *o = optctx;
1974 char layout_str[32];
1977 int ret, channels, ac_str_size;
1980 layout = av_get_channel_layout(arg);
1982 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1983 return AVERROR(EINVAL);
1985 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1986 ret = opt_default(NULL, opt, layout_str);
1990 /* set 'ac' option based on channel layout */
1991 channels = av_get_channel_layout_nb_channels(layout);
1992 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1993 stream_str = strchr(opt, ':');
1994 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1995 ac_str = av_mallocz(ac_str_size);
1997 return AVERROR(ENOMEM);
1998 av_strlcpy(ac_str, "ac", 3);
2000 av_strlcat(ac_str, stream_str, ac_str_size);
2001 ret = parse_option(o, ac_str, layout_str, options);
2007 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2009 OptionsContext *o = optctx;
2010 return parse_option(o, "q:a", arg, options);
2013 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2015 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2016 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2017 return AVERROR(ENOMEM);
2018 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2019 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2020 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2021 return AVERROR(ENOMEM);
2025 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2027 uint8_t *graph_desc = read_file(arg);
2029 return AVERROR(EINVAL);
2031 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2032 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2033 return AVERROR(ENOMEM);
2034 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2035 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2039 void show_help_default(const char *opt, const char *arg)
2041 /* per-file options have at least one of those set */
2042 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2043 int show_advanced = 0, show_avoptions = 0;
2046 if (!strcmp(opt, "long"))
2048 else if (!strcmp(opt, "full"))
2049 show_advanced = show_avoptions = 1;
2051 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2056 printf("Getting help:\n"
2057 " -h -- print basic options\n"
2058 " -h long -- print more options\n"
2059 " -h full -- print all options (including all format and codec specific options, very long)\n"
2060 " See man %s for detailed description of the options.\n"
2061 "\n", program_name);
2063 show_help_options(options, "Print help / information / capabilities:",
2066 show_help_options(options, "Global options (affect whole program "
2067 "instead of just one file:",
2068 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2070 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2071 per_file | OPT_EXIT, 0);
2073 show_help_options(options, "Per-file main options:", 0,
2074 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2075 OPT_EXIT, per_file);
2077 show_help_options(options, "Advanced per-file options:",
2078 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2080 show_help_options(options, "Video options:",
2081 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2083 show_help_options(options, "Advanced Video options:",
2084 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2086 show_help_options(options, "Audio options:",
2087 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2089 show_help_options(options, "Advanced Audio options:",
2090 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2091 show_help_options(options, "Subtitle options:",
2092 OPT_SUBTITLE, 0, 0);
2095 if (show_avoptions) {
2096 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2097 show_help_children(avcodec_get_class(), flags);
2098 show_help_children(avformat_get_class(), flags);
2099 show_help_children(sws_get_class(), flags);
2100 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2104 void show_usage(void)
2106 printf("Hyper fast Audio and Video encoder\n");
2107 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2116 static const OptionGroupDef groups[] = {
2117 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2118 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2121 static int open_files(OptionGroupList *l, const char *inout,
2122 int (*open_file)(OptionsContext*, const char*))
2126 for (i = 0; i < l->nb_groups; i++) {
2127 OptionGroup *g = &l->groups[i];
2133 ret = parse_optgroup(&o, g);
2135 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2136 "%s.\n", inout, g->arg);
2140 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2141 ret = open_file(&o, g->arg);
2144 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2148 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2154 int avconv_parse_options(int argc, char **argv)
2156 OptionParseContext octx;
2160 memset(&octx, 0, sizeof(octx));
2162 /* split the commandline into an internal representation */
2163 ret = split_commandline(&octx, argc, argv, options, groups,
2164 FF_ARRAY_ELEMS(groups));
2166 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2170 /* apply global options */
2171 ret = parse_optgroup(NULL, &octx.global_opts);
2173 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2177 /* open input files */
2178 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2180 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2184 /* open output files */
2185 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2187 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2192 uninit_parse_context(&octx);
2194 av_strerror(ret, error, sizeof(error));
2195 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2200 #define OFFSET(x) offsetof(OptionsContext, x)
2201 const OptionDef options[] = {
2203 #include "cmdutils_common_opts.h"
2204 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2205 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2206 "force format", "fmt" },
2207 { "y", OPT_BOOL, { &file_overwrite },
2208 "overwrite output files" },
2209 { "n", OPT_BOOL, { &file_skip },
2210 "never overwrite output files" },
2211 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2212 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2213 "codec name", "codec" },
2214 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2215 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2216 "codec name", "codec" },
2217 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2218 OPT_OUTPUT, { .off = OFFSET(presets) },
2219 "preset name", "preset" },
2220 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2221 OPT_OUTPUT, { .func_arg = opt_map },
2222 "set input stream mapping",
2223 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2224 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2225 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2226 "set metadata information of outfile from infile",
2227 "outfile[,metadata]:infile[,metadata]" },
2228 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2229 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2230 "set chapters mapping", "input_file_index" },
2231 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2232 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2233 "record or transcode \"duration\" seconds of audio/video",
2235 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2236 "set the limit file size in bytes", "limit_size" },
2237 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2238 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2239 "set the start time offset", "time_off" },
2240 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2241 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2242 "enable/disable accurate seeking with -ss" },
2243 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2244 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2245 "set the input ts offset", "time_off" },
2246 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2247 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2248 "set the input ts scale", "scale" },
2249 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2250 "add metadata", "string=string" },
2251 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2252 OPT_OUTPUT, { .func_arg = opt_data_frames },
2253 "set the number of data frames to record", "number" },
2254 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2255 "add timings for benchmarking" },
2256 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2257 "set max runtime in seconds", "limit" },
2258 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2259 "dump each input packet" },
2260 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2261 "when dumping packets, also dump the payload" },
2262 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2263 OPT_INPUT, { .off = OFFSET(rate_emu) },
2264 "read input at native frame rate", "" },
2265 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2266 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2267 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2268 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2269 "video sync method", "" },
2270 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2271 "audio sync method", "" },
2272 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2273 "audio drift threshold", "threshold" },
2274 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2275 "copy timestamps" },
2276 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2277 "copy input stream time base when stream copying" },
2278 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2279 OPT_OUTPUT, { .off = OFFSET(shortest) },
2280 "finish encoding within shortest input" },
2281 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2282 "timestamp discontinuity delta threshold", "threshold" },
2283 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2284 "exit on error", "error" },
2285 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2286 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2287 "copy initial non-keyframes" },
2288 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2289 "set the number of frames to record", "number" },
2290 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2291 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2292 "force codec tag/fourcc", "fourcc/tag" },
2293 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2294 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2295 "use fixed quality scale (VBR)", "q" },
2296 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2297 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2298 "use fixed quality scale (VBR)", "q" },
2299 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2300 "set stream filterchain", "filter_list" },
2301 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2302 "read stream filtergraph description from a file", "filename" },
2303 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2304 "create a complex filtergraph", "graph_description" },
2305 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2306 "read complex filtergraph description from a file", "filename" },
2307 { "stats", OPT_BOOL, { &print_stats },
2308 "print progress report during encoding", },
2309 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2310 OPT_OUTPUT, { .func_arg = opt_attach },
2311 "add an attachment to the output file", "filename" },
2312 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2313 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2314 "extract an attachment into a file", "filename" },
2317 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2318 "set the number of video frames to record", "number" },
2319 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2320 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2321 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2322 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2323 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2324 "set frame size (WxH or abbreviation)", "size" },
2325 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2326 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2327 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2328 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2329 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2330 "set pixel format", "format" },
2331 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2333 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2334 "discard threshold", "n" },
2335 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2336 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2337 "rate control override for specific intervals", "override" },
2338 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2339 OPT_OUTPUT, { .func_arg = opt_video_codec },
2340 "force video codec ('copy' to copy stream)", "codec" },
2341 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2342 "select the pass number (1 or 2)", "n" },
2343 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2344 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2345 "select two pass log file name prefix", "prefix" },
2346 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2347 "dump video coding statistics to file" },
2348 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2349 "dump video coding statistics to file", "file" },
2350 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2351 "video filters", "filter list" },
2352 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2353 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2354 "specify intra matrix coeffs", "matrix" },
2355 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2356 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2357 "specify inter matrix coeffs", "matrix" },
2358 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2359 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2360 "top=1/bottom=0/auto=-1 field first", "" },
2361 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2362 "intra_dc_precision", "precision" },
2363 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2364 OPT_OUTPUT, { .func_arg = opt_video_tag },
2365 "force video tag/fourcc", "fourcc/tag" },
2366 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2367 "show QP histogram" },
2368 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2369 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2370 "force the selected framerate, disable the best supported framerate selection" },
2371 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2372 OPT_OUTPUT, { .func_arg = opt_streamid },
2373 "set the value of an outfile streamid", "streamIndex:value" },
2374 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2375 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2376 "force key frames at specified timestamps", "timestamps" },
2377 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2378 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2379 "use HW accelerated decoding", "hwaccel name" },
2380 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2381 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2382 "select a device for HW acceleration" "devicename" },
2383 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2384 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2385 "automatically insert correct rotate filters" },
2388 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2389 "set the number of audio frames to record", "number" },
2390 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2391 "set audio quality (codec-specific)", "quality", },
2392 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2393 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2394 "set audio sampling rate (in Hz)", "rate" },
2395 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2396 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2397 "set number of audio channels", "channels" },
2398 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2400 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2401 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2402 "force audio codec ('copy' to copy stream)", "codec" },
2403 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2404 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2405 "force audio tag/fourcc", "fourcc/tag" },
2406 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2407 "change audio volume (256=normal)" , "volume" },
2408 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2409 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2410 "set sample format", "format" },
2411 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2412 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2413 "set channel layout", "layout" },
2414 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2415 "audio filters", "filter list" },
2417 /* subtitle options */
2418 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2419 "disable subtitle" },
2420 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2421 "force subtitle codec ('copy' to copy stream)", "codec" },
2422 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2423 , "force subtitle tag/fourcc", "fourcc/tag" },
2426 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2429 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2430 "set the maximum demux-decode delay", "seconds" },
2431 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2432 "set the initial demux-decode delay", "seconds" },
2434 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2435 "A comma-separated list of bitstream filters", "bitstream_filters" },
2437 /* data codec support */
2438 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2439 "force data codec ('copy' to copy stream)", "codec" },