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 /* parse sync stream first, just pick first matching stream */
218 if (sync = strchr(map, ',')) {
220 sync_file_idx = strtol(sync + 1, &sync, 0);
221 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
227 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
233 if (i == input_files[sync_file_idx]->nb_streams) {
234 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235 "match any streams.\n", arg);
242 /* this mapping refers to lavfi output */
243 const char *c = map + 1;
244 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
245 m = &o->stream_maps[o->nb_stream_maps - 1];
246 m->linklabel = av_get_token(&c, "]");
248 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
252 file_idx = strtol(map, &p, 0);
253 if (file_idx >= nb_input_files || file_idx < 0) {
254 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
258 /* disable some already defined maps */
259 for (i = 0; i < o->nb_stream_maps; i++) {
260 m = &o->stream_maps[i];
261 if (file_idx == m->file_index &&
262 check_stream_specifier(input_files[m->file_index]->ctx,
263 input_files[m->file_index]->ctx->streams[m->stream_index],
264 *p == ':' ? p + 1 : p) > 0)
268 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
269 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
270 *p == ':' ? p + 1 : p) <= 0)
272 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
273 m = &o->stream_maps[o->nb_stream_maps - 1];
275 m->file_index = file_idx;
278 if (sync_file_idx >= 0) {
279 m->sync_file_index = sync_file_idx;
280 m->sync_stream_index = sync_stream_idx;
282 m->sync_file_index = file_idx;
283 m->sync_stream_index = i;
289 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
297 static int opt_attach(void *optctx, const char *opt, const char *arg)
299 OptionsContext *o = optctx;
300 GROW_ARRAY(o->attachments, o->nb_attachments);
301 o->attachments[o->nb_attachments - 1] = arg;
306 * Parse a metadata specifier passed as 'arg' parameter.
307 * @param arg metadata string to parse
308 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
309 * @param index for type c/p, chapter/program index is written here
310 * @param stream_spec for type s, the stream specifier is written here
312 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
320 if (*(++arg) && *arg != ':') {
321 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
324 *stream_spec = *arg == ':' ? arg + 1 : "";
329 *index = strtol(++arg, NULL, 0);
332 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
339 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
341 AVDictionary **meta_in = NULL;
342 AVDictionary **meta_out;
344 char type_in, type_out;
345 const char *istream_spec = NULL, *ostream_spec = NULL;
346 int idx_in = 0, idx_out = 0;
348 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
349 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
351 if (type_in == 'g' || type_out == 'g')
352 o->metadata_global_manual = 1;
353 if (type_in == 's' || type_out == 's')
354 o->metadata_streams_manual = 1;
355 if (type_in == 'c' || type_out == 'c')
356 o->metadata_chapters_manual = 1;
358 /* ic is NULL when just disabling automatic mappings */
362 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
363 if ((index) < 0 || (index) >= (nb_elems)) {\
364 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
369 #define SET_DICT(type, meta, context, index)\
372 meta = &context->metadata;\
375 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
376 meta = &context->chapters[index]->metadata;\
379 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
380 meta = &context->programs[index]->metadata;\
383 break; /* handled separately below */ \
384 default: av_assert0(0);\
387 SET_DICT(type_in, meta_in, ic, idx_in);
388 SET_DICT(type_out, meta_out, oc, idx_out);
390 /* for input streams choose first matching stream */
391 if (type_in == 's') {
392 for (i = 0; i < ic->nb_streams; i++) {
393 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
394 meta_in = &ic->streams[i]->metadata;
400 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
405 if (type_out == 's') {
406 for (i = 0; i < oc->nb_streams; i++) {
407 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
408 meta_out = &oc->streams[i]->metadata;
409 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
414 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
419 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
421 const AVCodecDescriptor *desc;
422 const char *codec_string = encoder ? "encoder" : "decoder";
426 avcodec_find_encoder_by_name(name) :
427 avcodec_find_decoder_by_name(name);
429 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
430 codec = encoder ? avcodec_find_encoder(desc->id) :
431 avcodec_find_decoder(desc->id);
433 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
434 codec_string, codec->name, desc->name);
438 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
441 if (codec->type != type) {
442 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
448 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
450 char *codec_name = NULL;
452 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
454 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
455 st->codec->codec_id = codec->id;
458 return avcodec_find_decoder(st->codec->codec_id);
461 /* Add all the streams from the given input file to the global
462 * list of input streams. */
463 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
467 for (i = 0; i < ic->nb_streams; i++) {
468 AVStream *st = ic->streams[i];
469 AVCodecContext *dec = st->codec;
470 InputStream *ist = av_mallocz(sizeof(*ist));
471 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
472 char *codec_tag = NULL;
478 GROW_ARRAY(input_streams, nb_input_streams);
479 input_streams[nb_input_streams - 1] = ist;
482 ist->file_index = nb_input_files;
484 st->discard = AVDISCARD_ALL;
487 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
489 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
491 uint32_t tag = strtol(codec_tag, &next, 0);
493 tag = AV_RL32(codec_tag);
494 st->codec->codec_tag = tag;
497 ist->dec = choose_decoder(o, ic, st);
498 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
500 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
502 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
506 ret = avcodec_copy_context(ist->dec_ctx, dec);
508 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
512 switch (dec->codec_type) {
513 case AVMEDIA_TYPE_VIDEO:
514 ist->resample_height = ist->dec_ctx->height;
515 ist->resample_width = ist->dec_ctx->width;
516 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
518 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
519 if (framerate && av_parse_video_rate(&ist->framerate,
521 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
526 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
528 if (!strcmp(hwaccel, "none"))
529 ist->hwaccel_id = HWACCEL_NONE;
530 else if (!strcmp(hwaccel, "auto"))
531 ist->hwaccel_id = HWACCEL_AUTO;
534 for (i = 0; hwaccels[i].name; i++) {
535 if (!strcmp(hwaccels[i].name, hwaccel)) {
536 ist->hwaccel_id = hwaccels[i].id;
541 if (!ist->hwaccel_id) {
542 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
544 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
545 for (i = 0; hwaccels[i].name; i++)
546 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
547 av_log(NULL, AV_LOG_FATAL, "\n");
553 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
554 if (hwaccel_device) {
555 ist->hwaccel_device = av_strdup(hwaccel_device);
556 if (!ist->hwaccel_device)
559 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
562 case AVMEDIA_TYPE_AUDIO:
563 guess_input_channel_layout(ist);
565 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
566 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
567 ist->resample_channels = ist->dec_ctx->channels;
568 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
571 case AVMEDIA_TYPE_DATA:
572 case AVMEDIA_TYPE_SUBTITLE:
573 case AVMEDIA_TYPE_ATTACHMENT:
574 case AVMEDIA_TYPE_UNKNOWN:
582 static void assert_file_overwrite(const char *filename)
584 if (file_overwrite && file_skip) {
585 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
589 if (!file_overwrite &&
590 (!strchr(filename, ':') || filename[1] == ':' ||
591 av_strstart(filename, "file:", NULL))) {
592 if (avio_check(filename, 0) == 0) {
593 if (!using_stdin && !file_skip) {
594 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
597 fprintf(stderr, "Not overwriting - exiting\n");
602 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
609 static void dump_attachment(AVStream *st, const char *filename)
612 AVIOContext *out = NULL;
613 AVDictionaryEntry *e;
615 if (!st->codec->extradata_size) {
616 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
617 nb_input_files - 1, st->index);
620 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
623 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
624 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
628 assert_file_overwrite(filename);
630 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
631 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
636 avio_write(out, st->codec->extradata, st->codec->extradata_size);
641 static int open_input_file(OptionsContext *o, const char *filename)
645 AVInputFormat *file_iformat = NULL;
650 AVDictionary *unused_opts = NULL;
651 AVDictionaryEntry *e = NULL;
652 int orig_nb_streams; // number of streams before avformat_find_stream_info
655 if (!(file_iformat = av_find_input_format(o->format))) {
656 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
661 if (!strcmp(filename, "-"))
664 using_stdin |= !strncmp(filename, "pipe:", 5) ||
665 !strcmp(filename, "/dev/stdin");
667 /* get default parameters from command line */
668 ic = avformat_alloc_context();
670 print_error(filename, AVERROR(ENOMEM));
673 if (o->nb_audio_sample_rate) {
674 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
675 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
677 if (o->nb_audio_channels) {
678 /* because we set audio_channels based on both the "ac" and
679 * "channel_layout" options, we need to check that the specified
680 * demuxer actually has the "channels" option before setting it */
681 if (file_iformat && file_iformat->priv_class &&
682 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
683 AV_OPT_SEARCH_FAKE_OBJ)) {
684 snprintf(buf, sizeof(buf), "%d",
685 o->audio_channels[o->nb_audio_channels - 1].u.i);
686 av_dict_set(&o->g->format_opts, "channels", buf, 0);
689 if (o->nb_frame_rates) {
690 /* set the format-level framerate option;
691 * this is important for video grabbers, e.g. x11 */
692 if (file_iformat && file_iformat->priv_class &&
693 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
694 AV_OPT_SEARCH_FAKE_OBJ)) {
695 av_dict_set(&o->g->format_opts, "framerate",
696 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
699 if (o->nb_frame_sizes) {
700 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
702 if (o->nb_frame_pix_fmts)
703 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
705 ic->flags |= AVFMT_FLAG_NONBLOCK;
706 ic->interrupt_callback = int_cb;
708 /* open the input file with generic libav function */
709 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
711 print_error(filename, err);
714 assert_avoptions(o->g->format_opts);
716 /* apply forced codec ids */
717 for (i = 0; i < ic->nb_streams; i++)
718 choose_decoder(o, ic, ic->streams[i]);
720 /* Set AVCodecContext options for avformat_find_stream_info */
721 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
722 orig_nb_streams = ic->nb_streams;
724 /* If not enough info to get the stream parameters, we decode the
725 first frames to get it. (used in mpeg case for example) */
726 ret = avformat_find_stream_info(ic, opts);
728 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
729 avformat_close_input(&ic);
733 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
734 /* add the stream start time */
735 if (ic->start_time != AV_NOPTS_VALUE)
736 timestamp += ic->start_time;
738 /* if seeking requested, we execute it */
739 if (o->start_time != AV_NOPTS_VALUE) {
740 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
742 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
743 filename, (double)timestamp / AV_TIME_BASE);
747 /* update the current parameters so that they match the one of the input stream */
748 add_input_streams(o, ic);
750 /* dump the file content */
751 av_dump_format(ic, nb_input_files, filename, 0);
753 GROW_ARRAY(input_files, nb_input_files);
754 f = av_mallocz(sizeof(*f));
757 input_files[nb_input_files - 1] = f;
760 f->ist_index = nb_input_streams - ic->nb_streams;
761 f->start_time = o->start_time;
762 f->recording_time = o->recording_time;
763 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
764 f->nb_streams = ic->nb_streams;
765 f->rate_emu = o->rate_emu;
766 f->accurate_seek = o->accurate_seek;
768 /* check if all codec options have been used */
769 unused_opts = strip_specifiers(o->g->codec_opts);
770 for (i = f->ist_index; i < nb_input_streams; i++) {
772 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
773 AV_DICT_IGNORE_SUFFIX)))
774 av_dict_set(&unused_opts, e->key, NULL, 0);
778 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
779 const AVClass *class = avcodec_get_class();
780 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
781 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
784 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
785 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
786 "input file #%d (%s) is not a decoding option.\n", e->key,
787 option->help ? option->help : "", nb_input_files - 1,
792 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
793 "input file #%d (%s) has not been used for any stream. The most "
794 "likely reason is either wrong type (e.g. a video option with "
795 "no video streams) or that it is a private option of some decoder "
796 "which was not actually used for any stream.\n", e->key,
797 option->help ? option->help : "", nb_input_files - 1, filename);
799 av_dict_free(&unused_opts);
801 for (i = 0; i < o->nb_dump_attachment; i++) {
804 for (j = 0; j < ic->nb_streams; j++) {
805 AVStream *st = ic->streams[j];
807 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
808 dump_attachment(st, o->dump_attachment[i].u.str);
812 for (i = 0; i < orig_nb_streams; i++)
813 av_dict_free(&opts[i]);
819 static uint8_t *get_line(AVIOContext *s)
825 if (avio_open_dyn_buf(&line) < 0) {
826 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
830 while ((c = avio_r8(s)) && c != '\n')
833 avio_close_dyn_buf(line, &buf);
838 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
842 const char *base[3] = { getenv("AVCONV_DATADIR"),
847 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
851 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
852 i != 1 ? "" : "/.avconv", codec_name, preset_name);
853 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
856 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
857 i != 1 ? "" : "/.avconv", preset_name);
858 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
864 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
866 char *codec_name = NULL;
868 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
870 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
871 NULL, ost->st->codec->codec_type);
872 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
873 } else if (!strcmp(codec_name, "copy"))
874 ost->stream_copy = 1;
876 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
877 ost->st->codec->codec_id = ost->enc->id;
881 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
884 AVStream *st = avformat_new_stream(oc, NULL);
885 int idx = oc->nb_streams - 1, ret = 0;
886 char *bsf = NULL, *next, *codec_tag = NULL;
887 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
891 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
895 if (oc->nb_streams - 1 < o->nb_streamid_map)
896 st->id = o->streamid_map[oc->nb_streams - 1];
898 GROW_ARRAY(output_streams, nb_output_streams);
899 if (!(ost = av_mallocz(sizeof(*ost))))
901 output_streams[nb_output_streams - 1] = ost;
903 ost->file_index = nb_output_files - 1;
906 st->codec->codec_type = type;
907 choose_encoder(o, oc, ost);
909 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
911 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
914 ost->enc_ctx->codec_type = type;
917 AVIOContext *s = NULL;
918 char *buf = NULL, *arg = NULL, *preset = NULL;
920 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
922 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
923 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
926 if (!buf[0] || buf[0] == '#') {
930 if (!(arg = strchr(buf, '='))) {
931 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
935 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
937 } while (!s->eof_reached);
941 av_log(NULL, AV_LOG_FATAL,
942 "Preset %s specified for stream %d:%d, but could not be opened.\n",
943 preset, ost->file_index, ost->index);
947 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
950 ost->max_frames = INT64_MAX;
951 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
953 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
955 if (next = strchr(bsf, ','))
957 if (!(bsfc = av_bitstream_filter_init(bsf))) {
958 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
962 bsfc_prev->next = bsfc;
964 ost->bitstream_filters = bsfc;
970 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
972 uint32_t tag = strtol(codec_tag, &next, 0);
974 tag = AV_RL32(codec_tag);
975 ost->enc_ctx->codec_tag = tag;
978 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
980 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
981 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
984 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
985 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
987 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
989 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
991 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
992 ost->last_mux_dts = AV_NOPTS_VALUE;
997 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1000 const char *p = str;
1007 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1014 /* read file contents into a string */
1015 static uint8_t *read_file(const char *filename)
1017 AVIOContext *pb = NULL;
1018 AVIOContext *dyn_buf = NULL;
1019 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1020 uint8_t buf[1024], *str;
1023 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1027 ret = avio_open_dyn_buf(&dyn_buf);
1032 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1033 avio_write(dyn_buf, buf, ret);
1034 avio_w8(dyn_buf, 0);
1037 ret = avio_close_dyn_buf(dyn_buf, &str);
1043 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1046 AVStream *st = ost->st;
1047 char *filter = NULL, *filter_script = NULL;
1049 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1050 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1052 if (filter_script && filter) {
1053 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1054 "output stream #%d:%d.\n", nb_output_files, st->index);
1059 return read_file(filter_script);
1061 return av_strdup(filter);
1063 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1067 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1071 AVCodecContext *video_enc;
1072 char *frame_aspect_ratio = NULL;
1074 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1076 video_enc = ost->enc_ctx;
1078 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1079 if (frame_aspect_ratio)
1080 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1082 if (!ost->stream_copy) {
1083 const char *p = NULL;
1084 char *frame_rate = NULL, *frame_size = NULL;
1085 char *frame_pix_fmt = NULL;
1086 char *intra_matrix = NULL, *inter_matrix = NULL;
1090 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1091 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1092 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1096 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1097 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1098 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1102 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1103 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1104 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1107 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1109 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1111 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1112 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1115 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1117 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1119 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1120 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1123 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1126 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1127 for (i = 0; p; i++) {
1129 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1131 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1134 video_enc->rc_override =
1135 av_realloc(video_enc->rc_override,
1136 sizeof(RcOverride) * (i + 1));
1137 video_enc->rc_override[i].start_frame = start;
1138 video_enc->rc_override[i].end_frame = end;
1140 video_enc->rc_override[i].qscale = q;
1141 video_enc->rc_override[i].quality_factor = 1.0;
1144 video_enc->rc_override[i].qscale = 0;
1145 video_enc->rc_override[i].quality_factor = -q/100.0;
1150 video_enc->rc_override_count = i;
1151 video_enc->intra_dc_precision = intra_dc_precision - 8;
1154 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1157 video_enc->flags |= CODEC_FLAG_PASS1;
1159 video_enc->flags |= CODEC_FLAG_PASS2;
1163 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1164 if (ost->logfile_prefix &&
1165 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1168 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1169 if (ost->forced_keyframes)
1170 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1172 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1174 ost->top_field_first = -1;
1175 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1178 ost->avfilter = get_ost_filters(o, oc, ost);
1182 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1188 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1192 AVCodecContext *audio_enc;
1194 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1197 audio_enc = ost->enc_ctx;
1198 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1200 if (!ost->stream_copy) {
1201 char *sample_fmt = NULL;
1203 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1205 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1207 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1208 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1212 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1214 ost->avfilter = get_ost_filters(o, oc, ost);
1222 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1226 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1227 if (!ost->stream_copy) {
1228 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1235 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1237 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1238 ost->stream_copy = 1;
1243 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1246 AVCodecContext *subtitle_enc;
1248 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1249 subtitle_enc = ost->enc_ctx;
1251 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1256 /* arg format is "output-stream-index:streamid-value". */
1257 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1259 OptionsContext *o = optctx;
1264 av_strlcpy(idx_str, arg, sizeof(idx_str));
1265 p = strchr(idx_str, ':');
1267 av_log(NULL, AV_LOG_FATAL,
1268 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1273 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1274 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1275 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1279 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1281 AVFormatContext *is = ifile->ctx;
1282 AVFormatContext *os = ofile->ctx;
1286 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1288 return AVERROR(ENOMEM);
1291 for (i = 0; i < is->nb_chapters; i++) {
1292 AVChapter *in_ch = is->chapters[i], *out_ch;
1293 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1294 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1295 AV_TIME_BASE_Q, in_ch->time_base);
1296 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1297 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1300 if (in_ch->end < ts_off)
1302 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1305 out_ch = av_mallocz(sizeof(AVChapter));
1307 return AVERROR(ENOMEM);
1309 out_ch->id = in_ch->id;
1310 out_ch->time_base = in_ch->time_base;
1311 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1312 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1315 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1317 os->chapters[os->nb_chapters++] = out_ch;
1322 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1323 AVFormatContext *oc)
1327 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1328 ofilter->out_tmp->pad_idx)) {
1329 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1330 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1332 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1337 ost->source_index = -1;
1338 ost->filter = ofilter;
1342 if (ost->stream_copy) {
1343 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1344 "which is fed from a complex filtergraph. Filtering and streamcopy "
1345 "cannot be used together.\n", ost->file_index, ost->index);
1349 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1350 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1353 avfilter_inout_free(&ofilter->out_tmp);
1356 static int configure_complex_filters(void)
1360 for (i = 0; i < nb_filtergraphs; i++)
1361 if (!filtergraphs[i]->graph &&
1362 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1367 static int open_output_file(OptionsContext *o, const char *filename)
1369 AVFormatContext *oc;
1371 AVOutputFormat *file_oformat;
1375 AVDictionary *unused_opts = NULL;
1376 AVDictionaryEntry *e = NULL;
1378 if (configure_complex_filters() < 0) {
1379 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1383 GROW_ARRAY(output_files, nb_output_files);
1384 of = av_mallocz(sizeof(*of));
1387 output_files[nb_output_files - 1] = of;
1389 of->ost_index = nb_output_streams;
1390 of->recording_time = o->recording_time;
1391 of->start_time = o->start_time;
1392 of->limit_filesize = o->limit_filesize;
1393 of->shortest = o->shortest;
1394 av_dict_copy(&of->opts, o->g->format_opts, 0);
1396 if (!strcmp(filename, "-"))
1399 oc = avformat_alloc_context();
1401 print_error(filename, AVERROR(ENOMEM));
1405 if (o->recording_time != INT64_MAX)
1406 oc->duration = o->recording_time;
1409 file_oformat = av_guess_format(o->format, NULL, NULL);
1410 if (!file_oformat) {
1411 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1415 file_oformat = av_guess_format(NULL, filename, NULL);
1416 if (!file_oformat) {
1417 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1423 oc->oformat = file_oformat;
1424 oc->interrupt_callback = int_cb;
1425 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1427 /* create streams for all unlabeled output pads */
1428 for (i = 0; i < nb_filtergraphs; i++) {
1429 FilterGraph *fg = filtergraphs[i];
1430 for (j = 0; j < fg->nb_outputs; j++) {
1431 OutputFilter *ofilter = fg->outputs[j];
1433 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1436 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1437 ofilter->out_tmp->pad_idx)) {
1438 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1439 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1440 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1442 init_output_filter(ofilter, o, oc);
1446 if (!o->nb_stream_maps) {
1447 /* pick the "best" stream of each type */
1448 #define NEW_STREAM(type, index)\
1450 ost = new_ ## type ## _stream(o, oc);\
1451 ost->source_index = index;\
1452 ost->sync_ist = input_streams[index];\
1453 input_streams[index]->discard = 0;\
1454 input_streams[index]->st->discard = AVDISCARD_NONE;\
1457 /* video: highest resolution */
1458 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1459 int area = 0, idx = -1;
1460 for (i = 0; i < nb_input_streams; i++) {
1461 ist = input_streams[i];
1462 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1463 ist->st->codec->width * ist->st->codec->height > area) {
1464 area = ist->st->codec->width * ist->st->codec->height;
1468 NEW_STREAM(video, idx);
1471 /* audio: most channels */
1472 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1473 int channels = 0, idx = -1;
1474 for (i = 0; i < nb_input_streams; i++) {
1475 ist = input_streams[i];
1476 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1477 ist->st->codec->channels > channels) {
1478 channels = ist->st->codec->channels;
1482 NEW_STREAM(audio, idx);
1485 /* subtitles: pick first */
1486 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1487 for (i = 0; i < nb_input_streams; i++)
1488 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1489 NEW_STREAM(subtitle, i);
1493 /* do something with data? */
1495 for (i = 0; i < o->nb_stream_maps; i++) {
1496 StreamMap *map = &o->stream_maps[i];
1501 if (map->linklabel) {
1503 OutputFilter *ofilter = NULL;
1506 for (j = 0; j < nb_filtergraphs; j++) {
1507 fg = filtergraphs[j];
1508 for (k = 0; k < fg->nb_outputs; k++) {
1509 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1510 if (out && !strcmp(out->name, map->linklabel)) {
1511 ofilter = fg->outputs[k];
1518 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1519 "in any defined filter graph.\n", map->linklabel);
1522 init_output_filter(ofilter, o, oc);
1524 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1525 switch (ist->st->codec->codec_type) {
1526 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1527 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1528 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1529 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1530 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1532 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1533 map->file_index, map->stream_index);
1537 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1538 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1539 map->sync_stream_index];
1541 ist->st->discard = AVDISCARD_NONE;
1546 /* handle attached files */
1547 for (i = 0; i < o->nb_attachments; i++) {
1549 uint8_t *attachment;
1553 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1554 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1558 if ((len = avio_size(pb)) <= 0) {
1559 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1563 if (!(attachment = av_malloc(len))) {
1564 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1568 avio_read(pb, attachment, len);
1570 ost = new_attachment_stream(o, oc);
1571 ost->stream_copy = 0;
1572 ost->source_index = -1;
1573 ost->attachment_filename = o->attachments[i];
1574 ost->st->codec->extradata = attachment;
1575 ost->st->codec->extradata_size = len;
1577 p = strrchr(o->attachments[i], '/');
1578 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1582 /* check if all codec options have been used */
1583 unused_opts = strip_specifiers(o->g->codec_opts);
1584 for (i = of->ost_index; i < nb_output_streams; i++) {
1586 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1587 AV_DICT_IGNORE_SUFFIX)))
1588 av_dict_set(&unused_opts, e->key, NULL, 0);
1592 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1593 const AVClass *class = avcodec_get_class();
1594 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1595 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1598 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1599 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1600 "output file #%d (%s) is not an encoding option.\n", e->key,
1601 option->help ? option->help : "", nb_output_files - 1,
1606 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1607 "output file #%d (%s) has not been used for any stream. The most "
1608 "likely reason is either wrong type (e.g. a video option with "
1609 "no video streams) or that it is a private option of some encoder "
1610 "which was not actually used for any stream.\n", e->key,
1611 option->help ? option->help : "", nb_output_files - 1, filename);
1613 av_dict_free(&unused_opts);
1615 /* check filename in case of an image number is expected */
1616 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1617 if (!av_filename_number_test(oc->filename)) {
1618 print_error(oc->filename, AVERROR(EINVAL));
1623 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1624 /* test if it already exists to avoid losing precious files */
1625 assert_file_overwrite(filename);
1628 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1629 &oc->interrupt_callback,
1631 print_error(filename, err);
1636 if (o->mux_preload) {
1638 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1639 av_dict_set(&of->opts, "preload", buf, 0);
1641 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1642 oc->flags |= AVFMT_FLAG_NONBLOCK;
1645 for (i = 0; i < o->nb_metadata_map; i++) {
1647 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1649 if (in_file_index >= nb_input_files) {
1650 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1653 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1654 in_file_index >= 0 ?
1655 input_files[in_file_index]->ctx : NULL, o);
1659 if (o->chapters_input_file >= nb_input_files) {
1660 if (o->chapters_input_file == INT_MAX) {
1661 /* copy chapters from the first input file that has them*/
1662 o->chapters_input_file = -1;
1663 for (i = 0; i < nb_input_files; i++)
1664 if (input_files[i]->ctx->nb_chapters) {
1665 o->chapters_input_file = i;
1669 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1670 o->chapters_input_file);
1674 if (o->chapters_input_file >= 0)
1675 copy_chapters(input_files[o->chapters_input_file], of,
1676 !o->metadata_chapters_manual);
1678 /* copy global metadata by default */
1679 if (!o->metadata_global_manual && nb_input_files)
1680 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1681 AV_DICT_DONT_OVERWRITE);
1682 if (!o->metadata_streams_manual)
1683 for (i = of->ost_index; i < nb_output_streams; i++) {
1685 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1687 ist = input_streams[output_streams[i]->source_index];
1688 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1691 /* process manually set metadata */
1692 for (i = 0; i < o->nb_metadata; i++) {
1695 const char *stream_spec;
1696 int index = 0, j, ret;
1698 val = strchr(o->metadata[i].u.str, '=');
1700 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1701 o->metadata[i].u.str);
1706 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1708 for (j = 0; j < oc->nb_streams; j++) {
1709 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1710 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1721 if (index < 0 || index >= oc->nb_chapters) {
1722 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1725 m = &oc->chapters[index]->metadata;
1728 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1731 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1738 static int opt_target(void *optctx, const char *opt, const char *arg)
1740 OptionsContext *o = optctx;
1741 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1742 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1744 if (!strncmp(arg, "pal-", 4)) {
1747 } else if (!strncmp(arg, "ntsc-", 5)) {
1750 } else if (!strncmp(arg, "film-", 5)) {
1754 /* Try to determine PAL/NTSC by peeking in the input files */
1755 if (nb_input_files) {
1757 for (j = 0; j < nb_input_files; j++) {
1758 for (i = 0; i < input_files[j]->nb_streams; i++) {
1759 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1760 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1763 fr = c->time_base.den * 1000 / c->time_base.num;
1767 } else if ((fr == 29970) || (fr == 23976)) {
1772 if (norm != UNKNOWN)
1776 if (norm != UNKNOWN)
1777 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1780 if (norm == UNKNOWN) {
1781 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1782 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1783 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1787 if (!strcmp(arg, "vcd")) {
1788 opt_video_codec(o, "c:v", "mpeg1video");
1789 opt_audio_codec(o, "c:a", "mp2");
1790 parse_option(o, "f", "vcd", options);
1792 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1793 parse_option(o, "r", frame_rates[norm], options);
1794 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1796 opt_default(NULL, "b", "1150000");
1797 opt_default(NULL, "maxrate", "1150000");
1798 opt_default(NULL, "minrate", "1150000");
1799 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1801 opt_default(NULL, "b:a", "224000");
1802 parse_option(o, "ar", "44100", options);
1803 parse_option(o, "ac", "2", options);
1805 opt_default(NULL, "packetsize", "2324");
1806 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1808 /* We have to offset the PTS, so that it is consistent with the SCR.
1809 SCR starts at 36000, but the first two packs contain only padding
1810 and the first pack from the other stream, respectively, may also have
1811 been written before.
1812 So the real data starts at SCR 36000+3*1200. */
1813 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1814 } else if (!strcmp(arg, "svcd")) {
1816 opt_video_codec(o, "c:v", "mpeg2video");
1817 opt_audio_codec(o, "c:a", "mp2");
1818 parse_option(o, "f", "svcd", options);
1820 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1821 parse_option(o, "r", frame_rates[norm], options);
1822 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1824 opt_default(NULL, "b", "2040000");
1825 opt_default(NULL, "maxrate", "2516000");
1826 opt_default(NULL, "minrate", "0"); // 1145000;
1827 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1828 opt_default(NULL, "flags", "+scan_offset");
1831 opt_default(NULL, "b:a", "224000");
1832 parse_option(o, "ar", "44100", options);
1834 opt_default(NULL, "packetsize", "2324");
1836 } else if (!strcmp(arg, "dvd")) {
1838 opt_video_codec(o, "c:v", "mpeg2video");
1839 opt_audio_codec(o, "c:a", "ac3");
1840 parse_option(o, "f", "dvd", options);
1842 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1843 parse_option(o, "r", frame_rates[norm], options);
1844 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1846 opt_default(NULL, "b", "6000000");
1847 opt_default(NULL, "maxrate", "9000000");
1848 opt_default(NULL, "minrate", "0"); // 1500000;
1849 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1851 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1852 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1854 opt_default(NULL, "b:a", "448000");
1855 parse_option(o, "ar", "48000", options);
1857 } else if (!strncmp(arg, "dv", 2)) {
1859 parse_option(o, "f", "dv", options);
1861 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1862 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1863 norm == PAL ? "yuv420p" : "yuv411p", options);
1864 parse_option(o, "r", frame_rates[norm], options);
1866 parse_option(o, "ar", "48000", options);
1867 parse_option(o, "ac", "2", options);
1870 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1871 return AVERROR(EINVAL);
1874 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1875 av_dict_copy(&o->g->format_opts, format_opts, 0);
1880 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1882 av_free (vstats_filename);
1883 vstats_filename = av_strdup (arg);
1887 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1890 time_t today2 = time(NULL);
1891 struct tm *today = localtime(&today2);
1893 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1895 return opt_vstats_file(NULL, opt, filename);
1898 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1900 OptionsContext *o = optctx;
1901 return parse_option(o, "frames:v", arg, options);
1904 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1906 OptionsContext *o = optctx;
1907 return parse_option(o, "frames:a", arg, options);
1910 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1912 OptionsContext *o = optctx;
1913 return parse_option(o, "frames:d", arg, options);
1916 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1918 OptionsContext *o = optctx;
1919 return parse_option(o, "tag:v", arg, options);
1922 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1924 OptionsContext *o = optctx;
1925 return parse_option(o, "tag:a", arg, options);
1928 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1930 OptionsContext *o = optctx;
1931 return parse_option(o, "tag:s", arg, options);
1934 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1936 OptionsContext *o = optctx;
1937 return parse_option(o, "filter:v", arg, options);
1940 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1942 OptionsContext *o = optctx;
1943 return parse_option(o, "filter:a", arg, options);
1946 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1948 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1949 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1950 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1952 if (video_sync_method == VSYNC_AUTO)
1953 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1957 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1959 OptionsContext *o = optctx;
1960 char layout_str[32];
1963 int ret, channels, ac_str_size;
1966 layout = av_get_channel_layout(arg);
1968 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1969 return AVERROR(EINVAL);
1971 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1972 ret = opt_default(NULL, opt, layout_str);
1976 /* set 'ac' option based on channel layout */
1977 channels = av_get_channel_layout_nb_channels(layout);
1978 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1979 stream_str = strchr(opt, ':');
1980 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1981 ac_str = av_mallocz(ac_str_size);
1983 return AVERROR(ENOMEM);
1984 av_strlcpy(ac_str, "ac", 3);
1986 av_strlcat(ac_str, stream_str, ac_str_size);
1987 ret = parse_option(o, ac_str, layout_str, options);
1993 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1995 OptionsContext *o = optctx;
1996 return parse_option(o, "q:a", arg, options);
1999 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2001 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2002 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2003 return AVERROR(ENOMEM);
2004 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2005 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2006 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2007 return AVERROR(ENOMEM);
2011 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2013 uint8_t *graph_desc = read_file(arg);
2015 return AVERROR(EINVAL);
2017 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2018 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2019 return AVERROR(ENOMEM);
2020 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2021 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2025 void show_help_default(const char *opt, const char *arg)
2027 /* per-file options have at least one of those set */
2028 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2029 int show_advanced = 0, show_avoptions = 0;
2032 if (!strcmp(opt, "long"))
2034 else if (!strcmp(opt, "full"))
2035 show_advanced = show_avoptions = 1;
2037 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2042 printf("Getting help:\n"
2043 " -h -- print basic options\n"
2044 " -h long -- print more options\n"
2045 " -h full -- print all options (including all format and codec specific options, very long)\n"
2046 " See man %s for detailed description of the options.\n"
2047 "\n", program_name);
2049 show_help_options(options, "Print help / information / capabilities:",
2052 show_help_options(options, "Global options (affect whole program "
2053 "instead of just one file:",
2054 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2056 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2057 per_file | OPT_EXIT, 0);
2059 show_help_options(options, "Per-file main options:", 0,
2060 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2061 OPT_EXIT, per_file);
2063 show_help_options(options, "Advanced per-file options:",
2064 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2066 show_help_options(options, "Video options:",
2067 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2069 show_help_options(options, "Advanced Video options:",
2070 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2072 show_help_options(options, "Audio options:",
2073 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2075 show_help_options(options, "Advanced Audio options:",
2076 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2077 show_help_options(options, "Subtitle options:",
2078 OPT_SUBTITLE, 0, 0);
2081 if (show_avoptions) {
2082 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2083 show_help_children(avcodec_get_class(), flags);
2084 show_help_children(avformat_get_class(), flags);
2085 show_help_children(sws_get_class(), flags);
2086 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2090 void show_usage(void)
2092 printf("Hyper fast Audio and Video encoder\n");
2093 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2102 static const OptionGroupDef groups[] = {
2103 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2104 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2107 static int open_files(OptionGroupList *l, const char *inout,
2108 int (*open_file)(OptionsContext*, const char*))
2112 for (i = 0; i < l->nb_groups; i++) {
2113 OptionGroup *g = &l->groups[i];
2119 ret = parse_optgroup(&o, g);
2121 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2122 "%s.\n", inout, g->arg);
2126 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2127 ret = open_file(&o, g->arg);
2130 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2134 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2140 int avconv_parse_options(int argc, char **argv)
2142 OptionParseContext octx;
2146 memset(&octx, 0, sizeof(octx));
2148 /* split the commandline into an internal representation */
2149 ret = split_commandline(&octx, argc, argv, options, groups,
2150 FF_ARRAY_ELEMS(groups));
2152 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2156 /* apply global options */
2157 ret = parse_optgroup(NULL, &octx.global_opts);
2159 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2163 /* open input files */
2164 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2166 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2170 /* open output files */
2171 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2173 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2178 uninit_parse_context(&octx);
2180 av_strerror(ret, error, sizeof(error));
2181 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2186 #define OFFSET(x) offsetof(OptionsContext, x)
2187 const OptionDef options[] = {
2189 #include "cmdutils_common_opts.h"
2190 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2191 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2192 "force format", "fmt" },
2193 { "y", OPT_BOOL, { &file_overwrite },
2194 "overwrite output files" },
2195 { "n", OPT_BOOL, { &file_skip },
2196 "never overwrite output files" },
2197 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2198 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2199 "codec name", "codec" },
2200 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2201 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2202 "codec name", "codec" },
2203 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2204 OPT_OUTPUT, { .off = OFFSET(presets) },
2205 "preset name", "preset" },
2206 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2207 OPT_OUTPUT, { .func_arg = opt_map },
2208 "set input stream mapping",
2209 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2210 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2211 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2212 "set metadata information of outfile from infile",
2213 "outfile[,metadata]:infile[,metadata]" },
2214 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2215 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2216 "set chapters mapping", "input_file_index" },
2217 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2218 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2219 "record or transcode \"duration\" seconds of audio/video",
2221 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2222 "set the limit file size in bytes", "limit_size" },
2223 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2224 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2225 "set the start time offset", "time_off" },
2226 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2227 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2228 "enable/disable accurate seeking with -ss" },
2229 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2230 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2231 "set the input ts offset", "time_off" },
2232 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2233 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2234 "set the input ts scale", "scale" },
2235 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2236 "add metadata", "string=string" },
2237 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2238 OPT_OUTPUT, { .func_arg = opt_data_frames },
2239 "set the number of data frames to record", "number" },
2240 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2241 "add timings for benchmarking" },
2242 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2243 "set max runtime in seconds", "limit" },
2244 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2245 "dump each input packet" },
2246 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2247 "when dumping packets, also dump the payload" },
2248 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2249 OPT_INPUT, { .off = OFFSET(rate_emu) },
2250 "read input at native frame rate", "" },
2251 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2252 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2253 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2254 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2255 "video sync method", "" },
2256 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2257 "audio sync method", "" },
2258 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2259 "audio drift threshold", "threshold" },
2260 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2261 "copy timestamps" },
2262 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2263 "copy input stream time base when stream copying" },
2264 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2265 OPT_OUTPUT, { .off = OFFSET(shortest) },
2266 "finish encoding within shortest input" },
2267 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2268 "timestamp discontinuity delta threshold", "threshold" },
2269 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2270 "exit on error", "error" },
2271 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2272 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2273 "copy initial non-keyframes" },
2274 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2275 "set the number of frames to record", "number" },
2276 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2277 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2278 "force codec tag/fourcc", "fourcc/tag" },
2279 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2280 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2281 "use fixed quality scale (VBR)", "q" },
2282 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2283 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2284 "use fixed quality scale (VBR)", "q" },
2285 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2286 "set stream filterchain", "filter_list" },
2287 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2288 "read stream filtergraph description from a file", "filename" },
2289 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2290 "create a complex filtergraph", "graph_description" },
2291 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2292 "read complex filtergraph description from a file", "filename" },
2293 { "stats", OPT_BOOL, { &print_stats },
2294 "print progress report during encoding", },
2295 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2296 OPT_OUTPUT, { .func_arg = opt_attach },
2297 "add an attachment to the output file", "filename" },
2298 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2299 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2300 "extract an attachment into a file", "filename" },
2303 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2304 "set the number of video frames to record", "number" },
2305 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2306 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2307 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2308 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2309 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2310 "set frame size (WxH or abbreviation)", "size" },
2311 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2312 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2313 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2314 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2315 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2316 "set pixel format", "format" },
2317 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2319 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2320 "discard threshold", "n" },
2321 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2322 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2323 "rate control override for specific intervals", "override" },
2324 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2325 OPT_OUTPUT, { .func_arg = opt_video_codec },
2326 "force video codec ('copy' to copy stream)", "codec" },
2327 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2328 "select the pass number (1 or 2)", "n" },
2329 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2330 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2331 "select two pass log file name prefix", "prefix" },
2332 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2333 "dump video coding statistics to file" },
2334 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2335 "dump video coding statistics to file", "file" },
2336 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2337 "video filters", "filter list" },
2338 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2339 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2340 "specify intra matrix coeffs", "matrix" },
2341 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2342 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2343 "specify inter matrix coeffs", "matrix" },
2344 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2345 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2346 "top=1/bottom=0/auto=-1 field first", "" },
2347 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2348 "intra_dc_precision", "precision" },
2349 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2350 OPT_OUTPUT, { .func_arg = opt_video_tag },
2351 "force video tag/fourcc", "fourcc/tag" },
2352 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2353 "show QP histogram" },
2354 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2355 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2356 "force the selected framerate, disable the best supported framerate selection" },
2357 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2358 OPT_OUTPUT, { .func_arg = opt_streamid },
2359 "set the value of an outfile streamid", "streamIndex:value" },
2360 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2361 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2362 "force key frames at specified timestamps", "timestamps" },
2363 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2364 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2365 "use HW accelerated decoding", "hwaccel name" },
2366 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2367 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2368 "select a device for HW acceleration" "devicename" },
2371 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2372 "set the number of audio frames to record", "number" },
2373 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2374 "set audio quality (codec-specific)", "quality", },
2375 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2376 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2377 "set audio sampling rate (in Hz)", "rate" },
2378 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2379 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2380 "set number of audio channels", "channels" },
2381 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2383 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2384 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2385 "force audio codec ('copy' to copy stream)", "codec" },
2386 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2387 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2388 "force audio tag/fourcc", "fourcc/tag" },
2389 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2390 "change audio volume (256=normal)" , "volume" },
2391 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2392 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2393 "set sample format", "format" },
2394 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2395 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2396 "set channel layout", "layout" },
2397 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2398 "audio filters", "filter list" },
2400 /* subtitle options */
2401 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2402 "disable subtitle" },
2403 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2404 "force subtitle codec ('copy' to copy stream)", "codec" },
2405 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2406 , "force subtitle tag/fourcc", "fourcc/tag" },
2409 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2412 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2413 "set the maximum demux-decode delay", "seconds" },
2414 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2415 "set the initial demux-decode delay", "seconds" },
2417 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2418 "A comma-separated list of bitstream filters", "bitstream_filters" },
2420 /* data codec support */
2421 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2422 "force data codec ('copy' to copy stream)", "codec" },