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 DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 const HWAccel hwaccels[] = {
60 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
63 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
66 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
71 char *vstats_filename;
73 float audio_drift_threshold = 0.1;
74 float dts_delta_threshold = 10;
76 int audio_volume = 256;
77 int audio_sync_method = 0;
78 int video_sync_method = VSYNC_AUTO;
84 int exit_on_error = 0;
88 static int file_overwrite = 0;
89 static int file_skip = 0;
90 static int video_discard = 0;
91 static int intra_dc_precision = 8;
92 static int using_stdin = 0;
93 static int input_sync;
95 static void uninit_options(OptionsContext *o)
97 const OptionDef *po = options;
100 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
102 void *dst = (uint8_t*)o + po->u.off;
104 if (po->flags & OPT_SPEC) {
105 SpecifierOpt **so = dst;
106 int i, *count = (int*)(so + 1);
107 for (i = 0; i < *count; i++) {
108 av_freep(&(*so)[i].specifier);
109 if (po->flags & OPT_STRING)
110 av_freep(&(*so)[i].u.str);
114 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
119 for (i = 0; i < o->nb_stream_maps; i++)
120 av_freep(&o->stream_maps[i].linklabel);
121 av_freep(&o->stream_maps);
122 av_freep(&o->meta_data_maps);
123 av_freep(&o->streamid_map);
126 static void init_options(OptionsContext *o)
128 memset(o, 0, sizeof(*o));
130 o->mux_max_delay = 0.7;
131 o->start_time = AV_NOPTS_VALUE;
132 o->recording_time = INT64_MAX;
133 o->limit_filesize = UINT64_MAX;
134 o->chapters_input_file = INT_MAX;
135 o->accurate_seek = 1;
138 /* return a copy of the input with the stream specifiers removed from the keys */
139 static AVDictionary *strip_specifiers(AVDictionary *dict)
141 AVDictionaryEntry *e = NULL;
142 AVDictionary *ret = NULL;
144 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
145 char *p = strchr(e->key, ':');
149 av_dict_set(&ret, e->key, e->value, 0);
156 static double parse_frame_aspect_ratio(const char *arg)
163 p = strchr(arg, ':');
165 x = strtol(arg, &end, 10);
167 y = strtol(end + 1, &end, 10);
169 ar = (double)x / (double)y;
171 ar = strtod(arg, NULL);
174 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
180 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
182 OptionsContext *o = optctx;
183 return parse_option(o, "codec:a", arg, options);
186 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
188 OptionsContext *o = optctx;
189 return parse_option(o, "codec:v", arg, options);
192 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
194 OptionsContext *o = optctx;
195 return parse_option(o, "codec:s", arg, options);
198 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
201 return parse_option(o, "codec:d", arg, options);
204 static int opt_map(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
208 int i, negative = 0, file_idx;
209 int sync_file_idx = -1, sync_stream_idx;
217 map = av_strdup(arg);
219 return AVERROR(ENOMEM);
221 /* parse sync stream first, just pick first matching stream */
222 if (sync = strchr(map, ',')) {
224 sync_file_idx = strtol(sync + 1, &sync, 0);
225 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
226 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
231 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
232 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
233 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
237 if (i == input_files[sync_file_idx]->nb_streams) {
238 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
239 "match any streams.\n", arg);
246 /* this mapping refers to lavfi output */
247 const char *c = map + 1;
248 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
249 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->linklabel = av_get_token(&c, "]");
252 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
256 file_idx = strtol(map, &p, 0);
257 if (file_idx >= nb_input_files || file_idx < 0) {
258 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
262 /* disable some already defined maps */
263 for (i = 0; i < o->nb_stream_maps; i++) {
264 m = &o->stream_maps[i];
265 if (file_idx == m->file_index &&
266 check_stream_specifier(input_files[m->file_index]->ctx,
267 input_files[m->file_index]->ctx->streams[m->stream_index],
268 *p == ':' ? p + 1 : p) > 0)
272 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274 *p == ':' ? p + 1 : p) <= 0)
276 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
277 m = &o->stream_maps[o->nb_stream_maps - 1];
279 m->file_index = file_idx;
282 if (sync_file_idx >= 0) {
283 m->sync_file_index = sync_file_idx;
284 m->sync_stream_index = sync_stream_idx;
286 m->sync_file_index = file_idx;
287 m->sync_stream_index = i;
293 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
301 static int opt_attach(void *optctx, const char *opt, const char *arg)
303 OptionsContext *o = optctx;
304 GROW_ARRAY(o->attachments, o->nb_attachments);
305 o->attachments[o->nb_attachments - 1] = arg;
310 * Parse a metadata specifier passed as 'arg' parameter.
311 * @param arg metadata string to parse
312 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
313 * @param index for type c/p, chapter/program index is written here
314 * @param stream_spec for type s, the stream specifier is written here
316 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
324 if (*(++arg) && *arg != ':') {
325 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
328 *stream_spec = *arg == ':' ? arg + 1 : "";
333 *index = strtol(++arg, NULL, 0);
336 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
343 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
345 AVDictionary **meta_in = NULL;
346 AVDictionary **meta_out;
348 char type_in, type_out;
349 const char *istream_spec = NULL, *ostream_spec = NULL;
350 int idx_in = 0, idx_out = 0;
352 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
353 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
355 if (type_in == 'g' || type_out == 'g')
356 o->metadata_global_manual = 1;
357 if (type_in == 's' || type_out == 's')
358 o->metadata_streams_manual = 1;
359 if (type_in == 'c' || type_out == 'c')
360 o->metadata_chapters_manual = 1;
362 /* ic is NULL when just disabling automatic mappings */
366 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
367 if ((index) < 0 || (index) >= (nb_elems)) {\
368 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
373 #define SET_DICT(type, meta, context, index)\
376 meta = &context->metadata;\
379 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
380 meta = &context->chapters[index]->metadata;\
383 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
384 meta = &context->programs[index]->metadata;\
387 break; /* handled separately below */ \
388 default: av_assert0(0);\
391 SET_DICT(type_in, meta_in, ic, idx_in);
392 SET_DICT(type_out, meta_out, oc, idx_out);
394 /* for input streams choose first matching stream */
395 if (type_in == 's') {
396 for (i = 0; i < ic->nb_streams; i++) {
397 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
398 meta_in = &ic->streams[i]->metadata;
404 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
409 if (type_out == 's') {
410 for (i = 0; i < oc->nb_streams; i++) {
411 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
412 meta_out = &oc->streams[i]->metadata;
413 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
418 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
423 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
425 const AVCodecDescriptor *desc;
426 const char *codec_string = encoder ? "encoder" : "decoder";
430 avcodec_find_encoder_by_name(name) :
431 avcodec_find_decoder_by_name(name);
433 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
434 codec = encoder ? avcodec_find_encoder(desc->id) :
435 avcodec_find_decoder(desc->id);
437 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
438 codec_string, codec->name, desc->name);
442 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
445 if (codec->type != type) {
446 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
452 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
454 char *codec_name = NULL;
456 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
458 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
459 st->codec->codec_id = codec->id;
462 return avcodec_find_decoder(st->codec->codec_id);
465 /* Add all the streams from the given input file to the global
466 * list of input streams. */
467 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
471 for (i = 0; i < ic->nb_streams; i++) {
472 AVStream *st = ic->streams[i];
473 AVCodecContext *dec = st->codec;
474 InputStream *ist = av_mallocz(sizeof(*ist));
475 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
476 char *codec_tag = NULL;
482 GROW_ARRAY(input_streams, nb_input_streams);
483 input_streams[nb_input_streams - 1] = ist;
486 ist->file_index = nb_input_files;
488 st->discard = AVDISCARD_ALL;
491 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
494 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
496 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
498 uint32_t tag = strtol(codec_tag, &next, 0);
500 tag = AV_RL32(codec_tag);
501 st->codec->codec_tag = tag;
504 ist->dec = choose_decoder(o, ic, st);
505 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
507 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
509 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
513 ret = avcodec_copy_context(ist->dec_ctx, dec);
515 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
519 switch (dec->codec_type) {
520 case AVMEDIA_TYPE_VIDEO:
521 ist->resample_height = ist->dec_ctx->height;
522 ist->resample_width = ist->dec_ctx->width;
523 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
525 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
526 if (framerate && av_parse_video_rate(&ist->framerate,
528 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
533 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
535 if (!strcmp(hwaccel, "none"))
536 ist->hwaccel_id = HWACCEL_NONE;
537 else if (!strcmp(hwaccel, "auto"))
538 ist->hwaccel_id = HWACCEL_AUTO;
541 for (i = 0; hwaccels[i].name; i++) {
542 if (!strcmp(hwaccels[i].name, hwaccel)) {
543 ist->hwaccel_id = hwaccels[i].id;
548 if (!ist->hwaccel_id) {
549 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
551 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
552 for (i = 0; hwaccels[i].name; i++)
553 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
554 av_log(NULL, AV_LOG_FATAL, "\n");
560 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
561 if (hwaccel_device) {
562 ist->hwaccel_device = av_strdup(hwaccel_device);
563 if (!ist->hwaccel_device)
566 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
569 case AVMEDIA_TYPE_AUDIO:
570 guess_input_channel_layout(ist);
572 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
573 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
574 ist->resample_channels = ist->dec_ctx->channels;
575 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
578 case AVMEDIA_TYPE_DATA:
579 case AVMEDIA_TYPE_SUBTITLE:
580 case AVMEDIA_TYPE_ATTACHMENT:
581 case AVMEDIA_TYPE_UNKNOWN:
589 static void assert_file_overwrite(const char *filename)
591 if (file_overwrite && file_skip) {
592 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
596 if (!file_overwrite &&
597 (!strchr(filename, ':') || filename[1] == ':' ||
598 av_strstart(filename, "file:", NULL))) {
599 if (avio_check(filename, 0) == 0) {
600 if (!using_stdin && !file_skip) {
601 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
604 fprintf(stderr, "Not overwriting - exiting\n");
609 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
616 static void dump_attachment(AVStream *st, const char *filename)
619 AVIOContext *out = NULL;
620 AVDictionaryEntry *e;
622 if (!st->codec->extradata_size) {
623 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
624 nb_input_files - 1, st->index);
627 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
630 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
631 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
635 assert_file_overwrite(filename);
637 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
638 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
643 avio_write(out, st->codec->extradata, st->codec->extradata_size);
648 static int open_input_file(OptionsContext *o, const char *filename)
652 AVInputFormat *file_iformat = NULL;
657 AVDictionary *unused_opts = NULL;
658 AVDictionaryEntry *e = NULL;
659 int orig_nb_streams; // number of streams before avformat_find_stream_info
662 if (!(file_iformat = av_find_input_format(o->format))) {
663 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
668 if (!strcmp(filename, "-"))
671 using_stdin |= !strncmp(filename, "pipe:", 5) ||
672 !strcmp(filename, "/dev/stdin");
674 /* get default parameters from command line */
675 ic = avformat_alloc_context();
677 print_error(filename, AVERROR(ENOMEM));
680 if (o->nb_audio_sample_rate) {
681 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
682 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
684 if (o->nb_audio_channels) {
685 /* because we set audio_channels based on both the "ac" and
686 * "channel_layout" options, we need to check that the specified
687 * demuxer actually has the "channels" option before setting it */
688 if (file_iformat && file_iformat->priv_class &&
689 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
690 AV_OPT_SEARCH_FAKE_OBJ)) {
691 snprintf(buf, sizeof(buf), "%d",
692 o->audio_channels[o->nb_audio_channels - 1].u.i);
693 av_dict_set(&o->g->format_opts, "channels", buf, 0);
696 if (o->nb_frame_rates) {
697 /* set the format-level framerate option;
698 * this is important for video grabbers, e.g. x11 */
699 if (file_iformat && file_iformat->priv_class &&
700 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
701 AV_OPT_SEARCH_FAKE_OBJ)) {
702 av_dict_set(&o->g->format_opts, "framerate",
703 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
706 if (o->nb_frame_sizes) {
707 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
709 if (o->nb_frame_pix_fmts)
710 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
712 ic->flags |= AVFMT_FLAG_NONBLOCK;
713 ic->interrupt_callback = int_cb;
715 /* open the input file with generic libav function */
716 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
718 print_error(filename, err);
721 assert_avoptions(o->g->format_opts);
723 /* apply forced codec ids */
724 for (i = 0; i < ic->nb_streams; i++)
725 choose_decoder(o, ic, ic->streams[i]);
727 /* Set AVCodecContext options for avformat_find_stream_info */
728 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
729 orig_nb_streams = ic->nb_streams;
731 /* If not enough info to get the stream parameters, we decode the
732 first frames to get it. (used in mpeg case for example) */
733 ret = avformat_find_stream_info(ic, opts);
735 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
736 avformat_close_input(&ic);
740 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
741 /* add the stream start time */
742 if (ic->start_time != AV_NOPTS_VALUE)
743 timestamp += ic->start_time;
745 /* if seeking requested, we execute it */
746 if (o->start_time != AV_NOPTS_VALUE) {
747 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
749 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
750 filename, (double)timestamp / AV_TIME_BASE);
754 /* update the current parameters so that they match the one of the input stream */
755 add_input_streams(o, ic);
757 /* dump the file content */
758 av_dump_format(ic, nb_input_files, filename, 0);
760 GROW_ARRAY(input_files, nb_input_files);
761 f = av_mallocz(sizeof(*f));
764 input_files[nb_input_files - 1] = f;
767 f->ist_index = nb_input_streams - ic->nb_streams;
768 f->start_time = o->start_time;
769 f->recording_time = o->recording_time;
770 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
771 f->nb_streams = ic->nb_streams;
772 f->rate_emu = o->rate_emu;
773 f->accurate_seek = o->accurate_seek;
775 /* check if all codec options have been used */
776 unused_opts = strip_specifiers(o->g->codec_opts);
777 for (i = f->ist_index; i < nb_input_streams; i++) {
779 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
780 AV_DICT_IGNORE_SUFFIX)))
781 av_dict_set(&unused_opts, e->key, NULL, 0);
785 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
786 const AVClass *class = avcodec_get_class();
787 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
788 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
791 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
792 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
793 "input file #%d (%s) is not a decoding option.\n", e->key,
794 option->help ? option->help : "", nb_input_files - 1,
799 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
800 "input file #%d (%s) has not been used for any stream. The most "
801 "likely reason is either wrong type (e.g. a video option with "
802 "no video streams) or that it is a private option of some decoder "
803 "which was not actually used for any stream.\n", e->key,
804 option->help ? option->help : "", nb_input_files - 1, filename);
806 av_dict_free(&unused_opts);
808 for (i = 0; i < o->nb_dump_attachment; i++) {
811 for (j = 0; j < ic->nb_streams; j++) {
812 AVStream *st = ic->streams[j];
814 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
815 dump_attachment(st, o->dump_attachment[i].u.str);
819 for (i = 0; i < orig_nb_streams; i++)
820 av_dict_free(&opts[i]);
826 static uint8_t *get_line(AVIOContext *s)
832 if (avio_open_dyn_buf(&line) < 0) {
833 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
837 while ((c = avio_r8(s)) && c != '\n')
840 avio_close_dyn_buf(line, &buf);
845 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
849 const char *base[3] = { getenv("AVCONV_DATADIR"),
854 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
858 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
859 i != 1 ? "" : "/.avconv", codec_name, preset_name);
860 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
863 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
864 i != 1 ? "" : "/.avconv", preset_name);
865 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
871 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
873 char *codec_name = NULL;
875 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
877 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
878 NULL, ost->st->codec->codec_type);
879 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
880 } else if (!strcmp(codec_name, "copy"))
881 ost->stream_copy = 1;
883 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
884 ost->st->codec->codec_id = ost->enc->id;
888 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
891 AVStream *st = avformat_new_stream(oc, NULL);
892 int idx = oc->nb_streams - 1, ret = 0;
893 char *bsf = NULL, *next, *codec_tag = NULL;
894 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
898 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
902 if (oc->nb_streams - 1 < o->nb_streamid_map)
903 st->id = o->streamid_map[oc->nb_streams - 1];
905 GROW_ARRAY(output_streams, nb_output_streams);
906 if (!(ost = av_mallocz(sizeof(*ost))))
908 output_streams[nb_output_streams - 1] = ost;
910 ost->file_index = nb_output_files - 1;
913 st->codec->codec_type = type;
914 choose_encoder(o, oc, ost);
916 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
918 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
921 ost->enc_ctx->codec_type = type;
924 AVIOContext *s = NULL;
925 char *buf = NULL, *arg = NULL, *preset = NULL;
927 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
929 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
930 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
933 if (!buf[0] || buf[0] == '#') {
937 if (!(arg = strchr(buf, '='))) {
938 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
942 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
944 } while (!s->eof_reached);
948 av_log(NULL, AV_LOG_FATAL,
949 "Preset %s specified for stream %d:%d, but could not be opened.\n",
950 preset, ost->file_index, ost->index);
954 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
957 ost->max_frames = INT64_MAX;
958 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
960 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
962 if (next = strchr(bsf, ','))
964 if (!(bsfc = av_bitstream_filter_init(bsf))) {
965 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
969 bsfc_prev->next = bsfc;
971 ost->bitstream_filters = bsfc;
977 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
979 uint32_t tag = strtol(codec_tag, &next, 0);
981 tag = AV_RL32(codec_tag);
982 ost->enc_ctx->codec_tag = tag;
985 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
987 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
988 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
991 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
992 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
994 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
996 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
998 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
999 ost->last_mux_dts = AV_NOPTS_VALUE;
1004 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1007 const char *p = str;
1014 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1021 /* read file contents into a string */
1022 static uint8_t *read_file(const char *filename)
1024 AVIOContext *pb = NULL;
1025 AVIOContext *dyn_buf = NULL;
1026 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1027 uint8_t buf[1024], *str;
1030 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1034 ret = avio_open_dyn_buf(&dyn_buf);
1039 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1040 avio_write(dyn_buf, buf, ret);
1041 avio_w8(dyn_buf, 0);
1044 ret = avio_close_dyn_buf(dyn_buf, &str);
1050 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1053 AVStream *st = ost->st;
1054 char *filter = NULL, *filter_script = NULL;
1056 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1057 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1059 if (filter_script && filter) {
1060 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1061 "output stream #%d:%d.\n", nb_output_files, st->index);
1066 return read_file(filter_script);
1068 return av_strdup(filter);
1070 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1074 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1078 AVCodecContext *video_enc;
1079 char *frame_aspect_ratio = NULL;
1081 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1083 video_enc = ost->enc_ctx;
1085 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1086 if (frame_aspect_ratio)
1087 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1089 if (!ost->stream_copy) {
1090 const char *p = NULL;
1091 char *frame_rate = NULL, *frame_size = NULL;
1092 char *frame_pix_fmt = NULL;
1093 char *intra_matrix = NULL, *inter_matrix = NULL;
1097 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1098 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1099 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1103 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1104 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1105 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1109 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1110 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1111 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1114 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1116 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1118 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1119 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1122 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1124 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1126 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1127 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1130 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1133 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1134 for (i = 0; p; i++) {
1136 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1138 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1141 video_enc->rc_override =
1142 av_realloc(video_enc->rc_override,
1143 sizeof(RcOverride) * (i + 1));
1144 if (!video_enc->rc_override) {
1145 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1148 video_enc->rc_override[i].start_frame = start;
1149 video_enc->rc_override[i].end_frame = end;
1151 video_enc->rc_override[i].qscale = q;
1152 video_enc->rc_override[i].quality_factor = 1.0;
1155 video_enc->rc_override[i].qscale = 0;
1156 video_enc->rc_override[i].quality_factor = -q/100.0;
1161 video_enc->rc_override_count = i;
1162 video_enc->intra_dc_precision = intra_dc_precision - 8;
1165 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1168 video_enc->flags |= CODEC_FLAG_PASS1;
1170 video_enc->flags |= CODEC_FLAG_PASS2;
1174 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1175 if (ost->logfile_prefix &&
1176 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1180 char logfilename[1024];
1183 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1184 ost->logfile_prefix ? ost->logfile_prefix :
1185 DEFAULT_PASS_LOGFILENAME_PREFIX,
1187 if (!strcmp(ost->enc->name, "libx264")) {
1188 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1190 if (video_enc->flags & CODEC_FLAG_PASS1) {
1191 f = fopen(logfilename, "wb");
1193 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1194 logfilename, strerror(errno));
1199 char *logbuffer = read_file(logfilename);
1202 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1206 video_enc->stats_in = logbuffer;
1211 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1212 if (ost->forced_keyframes)
1213 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1215 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1217 ost->top_field_first = -1;
1218 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1221 ost->avfilter = get_ost_filters(o, oc, ost);
1225 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1231 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1235 AVCodecContext *audio_enc;
1237 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1240 audio_enc = ost->enc_ctx;
1241 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1243 if (!ost->stream_copy) {
1244 char *sample_fmt = NULL;
1246 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1248 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1250 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1251 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1255 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1257 ost->avfilter = get_ost_filters(o, oc, ost);
1265 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1269 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1270 if (!ost->stream_copy) {
1271 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1278 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1280 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1281 ost->stream_copy = 1;
1286 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1289 AVCodecContext *subtitle_enc;
1291 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1292 subtitle_enc = ost->enc_ctx;
1294 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1299 /* arg format is "output-stream-index:streamid-value". */
1300 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1302 OptionsContext *o = optctx;
1307 av_strlcpy(idx_str, arg, sizeof(idx_str));
1308 p = strchr(idx_str, ':');
1310 av_log(NULL, AV_LOG_FATAL,
1311 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1316 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1317 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1318 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1322 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1324 AVFormatContext *is = ifile->ctx;
1325 AVFormatContext *os = ofile->ctx;
1329 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1331 return AVERROR(ENOMEM);
1334 for (i = 0; i < is->nb_chapters; i++) {
1335 AVChapter *in_ch = is->chapters[i], *out_ch;
1336 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1337 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1338 AV_TIME_BASE_Q, in_ch->time_base);
1339 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1340 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1343 if (in_ch->end < ts_off)
1345 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1348 out_ch = av_mallocz(sizeof(AVChapter));
1350 return AVERROR(ENOMEM);
1352 out_ch->id = in_ch->id;
1353 out_ch->time_base = in_ch->time_base;
1354 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1355 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1358 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1360 os->chapters[os->nb_chapters++] = out_ch;
1365 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1366 AVFormatContext *oc)
1370 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1371 ofilter->out_tmp->pad_idx)) {
1372 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1373 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1375 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1380 ost->source_index = -1;
1381 ost->filter = ofilter;
1385 if (ost->stream_copy) {
1386 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1387 "which is fed from a complex filtergraph. Filtering and streamcopy "
1388 "cannot be used together.\n", ost->file_index, ost->index);
1392 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1393 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1396 avfilter_inout_free(&ofilter->out_tmp);
1399 static int configure_complex_filters(void)
1403 for (i = 0; i < nb_filtergraphs; i++)
1404 if (!filtergraphs[i]->graph &&
1405 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1410 static int open_output_file(OptionsContext *o, const char *filename)
1412 AVFormatContext *oc;
1414 AVOutputFormat *file_oformat;
1418 AVDictionary *unused_opts = NULL;
1419 AVDictionaryEntry *e = NULL;
1421 if (configure_complex_filters() < 0) {
1422 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1426 GROW_ARRAY(output_files, nb_output_files);
1427 of = av_mallocz(sizeof(*of));
1430 output_files[nb_output_files - 1] = of;
1432 of->ost_index = nb_output_streams;
1433 of->recording_time = o->recording_time;
1434 of->start_time = o->start_time;
1435 of->limit_filesize = o->limit_filesize;
1436 of->shortest = o->shortest;
1437 av_dict_copy(&of->opts, o->g->format_opts, 0);
1439 if (!strcmp(filename, "-"))
1442 oc = avformat_alloc_context();
1444 print_error(filename, AVERROR(ENOMEM));
1448 if (o->recording_time != INT64_MAX)
1449 oc->duration = o->recording_time;
1452 file_oformat = av_guess_format(o->format, NULL, NULL);
1453 if (!file_oformat) {
1454 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1458 file_oformat = av_guess_format(NULL, filename, NULL);
1459 if (!file_oformat) {
1460 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1466 oc->oformat = file_oformat;
1467 oc->interrupt_callback = int_cb;
1468 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1470 /* create streams for all unlabeled output pads */
1471 for (i = 0; i < nb_filtergraphs; i++) {
1472 FilterGraph *fg = filtergraphs[i];
1473 for (j = 0; j < fg->nb_outputs; j++) {
1474 OutputFilter *ofilter = fg->outputs[j];
1476 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1479 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1480 ofilter->out_tmp->pad_idx)) {
1481 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1482 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1483 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1485 init_output_filter(ofilter, o, oc);
1489 if (!o->nb_stream_maps) {
1490 /* pick the "best" stream of each type */
1491 #define NEW_STREAM(type, index)\
1493 ost = new_ ## type ## _stream(o, oc);\
1494 ost->source_index = index;\
1495 ost->sync_ist = input_streams[index];\
1496 input_streams[index]->discard = 0;\
1497 input_streams[index]->st->discard = AVDISCARD_NONE;\
1500 /* video: highest resolution */
1501 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1502 int area = 0, idx = -1;
1503 for (i = 0; i < nb_input_streams; i++) {
1504 ist = input_streams[i];
1505 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1506 ist->st->codec->width * ist->st->codec->height > area) {
1507 area = ist->st->codec->width * ist->st->codec->height;
1511 NEW_STREAM(video, idx);
1514 /* audio: most channels */
1515 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1516 int channels = 0, idx = -1;
1517 for (i = 0; i < nb_input_streams; i++) {
1518 ist = input_streams[i];
1519 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1520 ist->st->codec->channels > channels) {
1521 channels = ist->st->codec->channels;
1525 NEW_STREAM(audio, idx);
1528 /* subtitles: pick first */
1529 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1530 for (i = 0; i < nb_input_streams; i++)
1531 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1532 NEW_STREAM(subtitle, i);
1536 /* do something with data? */
1538 for (i = 0; i < o->nb_stream_maps; i++) {
1539 StreamMap *map = &o->stream_maps[i];
1544 if (map->linklabel) {
1546 OutputFilter *ofilter = NULL;
1549 for (j = 0; j < nb_filtergraphs; j++) {
1550 fg = filtergraphs[j];
1551 for (k = 0; k < fg->nb_outputs; k++) {
1552 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1553 if (out && !strcmp(out->name, map->linklabel)) {
1554 ofilter = fg->outputs[k];
1561 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1562 "in any defined filter graph.\n", map->linklabel);
1565 init_output_filter(ofilter, o, oc);
1567 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1568 switch (ist->st->codec->codec_type) {
1569 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1570 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1571 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1572 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1573 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1575 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1576 map->file_index, map->stream_index);
1580 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1581 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1582 map->sync_stream_index];
1584 ist->st->discard = AVDISCARD_NONE;
1589 /* handle attached files */
1590 for (i = 0; i < o->nb_attachments; i++) {
1592 uint8_t *attachment;
1596 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1597 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1601 if ((len = avio_size(pb)) <= 0) {
1602 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1606 if (!(attachment = av_malloc(len))) {
1607 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1611 avio_read(pb, attachment, len);
1613 ost = new_attachment_stream(o, oc);
1614 ost->stream_copy = 0;
1615 ost->source_index = -1;
1616 ost->attachment_filename = o->attachments[i];
1617 ost->st->codec->extradata = attachment;
1618 ost->st->codec->extradata_size = len;
1620 p = strrchr(o->attachments[i], '/');
1621 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1625 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1626 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1627 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1631 /* check if all codec options have been used */
1632 unused_opts = strip_specifiers(o->g->codec_opts);
1633 for (i = of->ost_index; i < nb_output_streams; i++) {
1635 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1636 AV_DICT_IGNORE_SUFFIX)))
1637 av_dict_set(&unused_opts, e->key, NULL, 0);
1641 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1642 const AVClass *class = avcodec_get_class();
1643 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1644 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1647 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1648 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1649 "output file #%d (%s) is not an encoding option.\n", e->key,
1650 option->help ? option->help : "", nb_output_files - 1,
1655 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1656 "output file #%d (%s) has not been used for any stream. The most "
1657 "likely reason is either wrong type (e.g. a video option with "
1658 "no video streams) or that it is a private option of some encoder "
1659 "which was not actually used for any stream.\n", e->key,
1660 option->help ? option->help : "", nb_output_files - 1, filename);
1662 av_dict_free(&unused_opts);
1664 /* set the encoding/decoding_needed flags */
1665 for (i = of->ost_index; i < nb_output_streams; i++) {
1666 OutputStream *ost = output_streams[i];
1668 ost->encoding_needed = !ost->stream_copy;
1669 if (ost->encoding_needed && ost->source_index >= 0) {
1670 InputStream *ist = input_streams[ost->source_index];
1671 ist->decoding_needed = 1;
1675 /* check filename in case of an image number is expected */
1676 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1677 if (!av_filename_number_test(oc->filename)) {
1678 print_error(oc->filename, AVERROR(EINVAL));
1683 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1684 /* test if it already exists to avoid losing precious files */
1685 assert_file_overwrite(filename);
1688 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1689 &oc->interrupt_callback,
1691 print_error(filename, err);
1696 if (o->mux_preload) {
1698 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1699 av_dict_set(&of->opts, "preload", buf, 0);
1701 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1702 oc->flags |= AVFMT_FLAG_NONBLOCK;
1705 for (i = 0; i < o->nb_metadata_map; i++) {
1707 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1709 if (in_file_index >= nb_input_files) {
1710 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1713 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1714 in_file_index >= 0 ?
1715 input_files[in_file_index]->ctx : NULL, o);
1719 if (o->chapters_input_file >= nb_input_files) {
1720 if (o->chapters_input_file == INT_MAX) {
1721 /* copy chapters from the first input file that has them*/
1722 o->chapters_input_file = -1;
1723 for (i = 0; i < nb_input_files; i++)
1724 if (input_files[i]->ctx->nb_chapters) {
1725 o->chapters_input_file = i;
1729 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1730 o->chapters_input_file);
1734 if (o->chapters_input_file >= 0)
1735 copy_chapters(input_files[o->chapters_input_file], of,
1736 !o->metadata_chapters_manual);
1738 /* copy global metadata by default */
1739 if (!o->metadata_global_manual && nb_input_files)
1740 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1741 AV_DICT_DONT_OVERWRITE);
1742 if (!o->metadata_streams_manual)
1743 for (i = of->ost_index; i < nb_output_streams; i++) {
1745 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1747 ist = input_streams[output_streams[i]->source_index];
1748 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1751 /* process manually set metadata */
1752 for (i = 0; i < o->nb_metadata; i++) {
1755 const char *stream_spec;
1756 int index = 0, j, ret;
1758 val = strchr(o->metadata[i].u.str, '=');
1760 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1761 o->metadata[i].u.str);
1766 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1768 for (j = 0; j < oc->nb_streams; j++) {
1769 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1770 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1781 if (index < 0 || index >= oc->nb_chapters) {
1782 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1785 m = &oc->chapters[index]->metadata;
1788 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1791 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1798 static int opt_target(void *optctx, const char *opt, const char *arg)
1800 OptionsContext *o = optctx;
1801 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1802 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1804 if (!strncmp(arg, "pal-", 4)) {
1807 } else if (!strncmp(arg, "ntsc-", 5)) {
1810 } else if (!strncmp(arg, "film-", 5)) {
1814 /* Try to determine PAL/NTSC by peeking in the input files */
1815 if (nb_input_files) {
1817 for (j = 0; j < nb_input_files; j++) {
1818 for (i = 0; i < input_files[j]->nb_streams; i++) {
1819 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1820 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
1823 fr = c->time_base.den * 1000 / c->time_base.num;
1827 } else if ((fr == 29970) || (fr == 23976)) {
1832 if (norm != UNKNOWN)
1836 if (norm != UNKNOWN)
1837 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1840 if (norm == UNKNOWN) {
1841 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1842 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1843 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1847 if (!strcmp(arg, "vcd")) {
1848 opt_video_codec(o, "c:v", "mpeg1video");
1849 opt_audio_codec(o, "c:a", "mp2");
1850 parse_option(o, "f", "vcd", options);
1852 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1853 parse_option(o, "r", frame_rates[norm], options);
1854 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1856 opt_default(NULL, "b", "1150000");
1857 opt_default(NULL, "maxrate", "1150000");
1858 opt_default(NULL, "minrate", "1150000");
1859 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1861 opt_default(NULL, "b:a", "224000");
1862 parse_option(o, "ar", "44100", options);
1863 parse_option(o, "ac", "2", options);
1865 opt_default(NULL, "packetsize", "2324");
1866 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
1868 /* We have to offset the PTS, so that it is consistent with the SCR.
1869 SCR starts at 36000, but the first two packs contain only padding
1870 and the first pack from the other stream, respectively, may also have
1871 been written before.
1872 So the real data starts at SCR 36000+3*1200. */
1873 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1874 } else if (!strcmp(arg, "svcd")) {
1876 opt_video_codec(o, "c:v", "mpeg2video");
1877 opt_audio_codec(o, "c:a", "mp2");
1878 parse_option(o, "f", "svcd", options);
1880 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1881 parse_option(o, "r", frame_rates[norm], options);
1882 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1884 opt_default(NULL, "b", "2040000");
1885 opt_default(NULL, "maxrate", "2516000");
1886 opt_default(NULL, "minrate", "0"); // 1145000;
1887 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1888 opt_default(NULL, "scan_offset", "1");
1891 opt_default(NULL, "b:a", "224000");
1892 parse_option(o, "ar", "44100", options);
1894 opt_default(NULL, "packetsize", "2324");
1896 } else if (!strcmp(arg, "dvd")) {
1898 opt_video_codec(o, "c:v", "mpeg2video");
1899 opt_audio_codec(o, "c:a", "ac3");
1900 parse_option(o, "f", "dvd", options);
1902 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1903 parse_option(o, "r", frame_rates[norm], options);
1904 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1906 opt_default(NULL, "b", "6000000");
1907 opt_default(NULL, "maxrate", "9000000");
1908 opt_default(NULL, "minrate", "0"); // 1500000;
1909 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1911 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1912 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
1914 opt_default(NULL, "b:a", "448000");
1915 parse_option(o, "ar", "48000", options);
1917 } else if (!strncmp(arg, "dv", 2)) {
1919 parse_option(o, "f", "dv", options);
1921 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1922 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1923 norm == PAL ? "yuv420p" : "yuv411p", options);
1924 parse_option(o, "r", frame_rates[norm], options);
1926 parse_option(o, "ar", "48000", options);
1927 parse_option(o, "ac", "2", options);
1930 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1931 return AVERROR(EINVAL);
1934 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
1935 av_dict_copy(&o->g->format_opts, format_opts, 0);
1940 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1942 av_free (vstats_filename);
1943 vstats_filename = av_strdup (arg);
1947 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1950 time_t today2 = time(NULL);
1951 struct tm *today = localtime(&today2);
1953 if (!today) { // maybe tomorrow
1954 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
1958 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1960 return opt_vstats_file(NULL, opt, filename);
1963 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1965 OptionsContext *o = optctx;
1966 return parse_option(o, "frames:v", arg, options);
1969 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1971 OptionsContext *o = optctx;
1972 return parse_option(o, "frames:a", arg, options);
1975 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1977 OptionsContext *o = optctx;
1978 return parse_option(o, "frames:d", arg, options);
1981 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1983 OptionsContext *o = optctx;
1984 return parse_option(o, "tag:v", arg, options);
1987 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1989 OptionsContext *o = optctx;
1990 return parse_option(o, "tag:a", arg, options);
1993 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1995 OptionsContext *o = optctx;
1996 return parse_option(o, "tag:s", arg, options);
1999 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2001 OptionsContext *o = optctx;
2002 return parse_option(o, "filter:v", arg, options);
2005 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2007 OptionsContext *o = optctx;
2008 return parse_option(o, "filter:a", arg, options);
2011 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2013 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2014 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2015 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2017 if (video_sync_method == VSYNC_AUTO)
2018 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2022 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2024 OptionsContext *o = optctx;
2025 char layout_str[32];
2028 int ret, channels, ac_str_size;
2031 layout = av_get_channel_layout(arg);
2033 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2034 return AVERROR(EINVAL);
2036 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2037 ret = opt_default(NULL, opt, layout_str);
2041 /* set 'ac' option based on channel layout */
2042 channels = av_get_channel_layout_nb_channels(layout);
2043 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2044 stream_str = strchr(opt, ':');
2045 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2046 ac_str = av_mallocz(ac_str_size);
2048 return AVERROR(ENOMEM);
2049 av_strlcpy(ac_str, "ac", 3);
2051 av_strlcat(ac_str, stream_str, ac_str_size);
2052 ret = parse_option(o, ac_str, layout_str, options);
2058 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2060 OptionsContext *o = optctx;
2061 return parse_option(o, "q:a", arg, options);
2064 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2066 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2067 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2068 return AVERROR(ENOMEM);
2069 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2070 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2071 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2072 return AVERROR(ENOMEM);
2076 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2078 uint8_t *graph_desc = read_file(arg);
2080 return AVERROR(EINVAL);
2082 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2083 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2084 return AVERROR(ENOMEM);
2085 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2086 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2090 void show_help_default(const char *opt, const char *arg)
2092 /* per-file options have at least one of those set */
2093 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2094 int show_advanced = 0, show_avoptions = 0;
2097 if (!strcmp(opt, "long"))
2099 else if (!strcmp(opt, "full"))
2100 show_advanced = show_avoptions = 1;
2102 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2107 printf("Getting help:\n"
2108 " -h -- print basic options\n"
2109 " -h long -- print more options\n"
2110 " -h full -- print all options (including all format and codec specific options, very long)\n"
2111 " See man %s for detailed description of the options.\n"
2112 "\n", program_name);
2114 show_help_options(options, "Print help / information / capabilities:",
2117 show_help_options(options, "Global options (affect whole program "
2118 "instead of just one file:",
2119 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2121 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2122 per_file | OPT_EXIT, 0);
2124 show_help_options(options, "Per-file main options:", 0,
2125 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2126 OPT_EXIT, per_file);
2128 show_help_options(options, "Advanced per-file options:",
2129 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2131 show_help_options(options, "Video options:",
2132 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2134 show_help_options(options, "Advanced Video options:",
2135 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2137 show_help_options(options, "Audio options:",
2138 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2140 show_help_options(options, "Advanced Audio options:",
2141 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2142 show_help_options(options, "Subtitle options:",
2143 OPT_SUBTITLE, 0, 0);
2146 if (show_avoptions) {
2147 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2148 show_help_children(avcodec_get_class(), flags);
2149 show_help_children(avformat_get_class(), flags);
2150 show_help_children(sws_get_class(), flags);
2151 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2155 void show_usage(void)
2157 printf("Hyper fast Audio and Video encoder\n");
2158 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2167 static const OptionGroupDef groups[] = {
2168 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2169 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2172 static int open_files(OptionGroupList *l, const char *inout,
2173 int (*open_file)(OptionsContext*, const char*))
2177 for (i = 0; i < l->nb_groups; i++) {
2178 OptionGroup *g = &l->groups[i];
2184 ret = parse_optgroup(&o, g);
2186 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2187 "%s.\n", inout, g->arg);
2191 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2192 ret = open_file(&o, g->arg);
2195 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2199 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2205 int avconv_parse_options(int argc, char **argv)
2207 OptionParseContext octx;
2211 memset(&octx, 0, sizeof(octx));
2213 /* split the commandline into an internal representation */
2214 ret = split_commandline(&octx, argc, argv, options, groups,
2215 FF_ARRAY_ELEMS(groups));
2217 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2221 /* apply global options */
2222 ret = parse_optgroup(NULL, &octx.global_opts);
2224 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2228 /* open input files */
2229 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2231 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2235 /* open output files */
2236 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2238 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2243 uninit_parse_context(&octx);
2245 av_strerror(ret, error, sizeof(error));
2246 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2251 #define OFFSET(x) offsetof(OptionsContext, x)
2252 const OptionDef options[] = {
2254 #include "cmdutils_common_opts.h"
2255 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2256 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2257 "force format", "fmt" },
2258 { "y", OPT_BOOL, { &file_overwrite },
2259 "overwrite output files" },
2260 { "n", OPT_BOOL, { &file_skip },
2261 "never overwrite output files" },
2262 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2263 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2264 "codec name", "codec" },
2265 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2266 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2267 "codec name", "codec" },
2268 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2269 OPT_OUTPUT, { .off = OFFSET(presets) },
2270 "preset name", "preset" },
2271 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2272 OPT_OUTPUT, { .func_arg = opt_map },
2273 "set input stream mapping",
2274 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2275 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2276 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2277 "set metadata information of outfile from infile",
2278 "outfile[,metadata]:infile[,metadata]" },
2279 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2280 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2281 "set chapters mapping", "input_file_index" },
2282 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2283 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2284 "record or transcode \"duration\" seconds of audio/video",
2286 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2287 "set the limit file size in bytes", "limit_size" },
2288 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2289 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2290 "set the start time offset", "time_off" },
2291 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2292 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2293 "enable/disable accurate seeking with -ss" },
2294 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2295 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2296 "set the input ts offset", "time_off" },
2297 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2298 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2299 "set the input ts scale", "scale" },
2300 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2301 "add metadata", "string=string" },
2302 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2303 OPT_OUTPUT, { .func_arg = opt_data_frames },
2304 "set the number of data frames to record", "number" },
2305 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2306 "add timings for benchmarking" },
2307 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2308 "set max runtime in seconds", "limit" },
2309 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2310 "dump each input packet" },
2311 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2312 "when dumping packets, also dump the payload" },
2313 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2314 OPT_INPUT, { .off = OFFSET(rate_emu) },
2315 "read input at native frame rate", "" },
2316 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2317 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2318 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2319 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2320 "video sync method", "" },
2321 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2322 "audio sync method", "" },
2323 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2324 "audio drift threshold", "threshold" },
2325 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2326 "copy timestamps" },
2327 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2328 "copy input stream time base when stream copying" },
2329 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2330 OPT_OUTPUT, { .off = OFFSET(shortest) },
2331 "finish encoding within shortest input" },
2332 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2333 "timestamp discontinuity delta threshold", "threshold" },
2334 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2335 "exit on error", "error" },
2336 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2337 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2338 "copy initial non-keyframes" },
2339 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2340 "set the number of frames to record", "number" },
2341 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2342 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2343 "force codec tag/fourcc", "fourcc/tag" },
2344 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2345 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2346 "use fixed quality scale (VBR)", "q" },
2347 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2348 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2349 "use fixed quality scale (VBR)", "q" },
2350 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2351 "set stream filterchain", "filter_list" },
2352 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2353 "read stream filtergraph description from a file", "filename" },
2354 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2355 "create a complex filtergraph", "graph_description" },
2356 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2357 "read complex filtergraph description from a file", "filename" },
2358 { "stats", OPT_BOOL, { &print_stats },
2359 "print progress report during encoding", },
2360 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2361 OPT_OUTPUT, { .func_arg = opt_attach },
2362 "add an attachment to the output file", "filename" },
2363 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2364 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2365 "extract an attachment into a file", "filename" },
2368 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2369 "set the number of video frames to record", "number" },
2370 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2371 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2372 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2373 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2374 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2375 "set frame size (WxH or abbreviation)", "size" },
2376 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2377 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2378 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2379 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2380 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2381 "set pixel format", "format" },
2382 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2384 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2385 "discard threshold", "n" },
2386 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2387 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2388 "rate control override for specific intervals", "override" },
2389 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2390 OPT_OUTPUT, { .func_arg = opt_video_codec },
2391 "force video codec ('copy' to copy stream)", "codec" },
2392 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2393 "select the pass number (1 or 2)", "n" },
2394 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2395 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2396 "select two pass log file name prefix", "prefix" },
2397 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2398 "dump video coding statistics to file" },
2399 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2400 "dump video coding statistics to file", "file" },
2401 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2402 "video filters", "filter list" },
2403 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2404 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2405 "specify intra matrix coeffs", "matrix" },
2406 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2407 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2408 "specify inter matrix coeffs", "matrix" },
2409 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2410 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2411 "top=1/bottom=0/auto=-1 field first", "" },
2412 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2413 "intra_dc_precision", "precision" },
2414 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2415 OPT_OUTPUT, { .func_arg = opt_video_tag },
2416 "force video tag/fourcc", "fourcc/tag" },
2417 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2418 "show QP histogram" },
2419 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2420 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2421 "force the selected framerate, disable the best supported framerate selection" },
2422 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2423 OPT_OUTPUT, { .func_arg = opt_streamid },
2424 "set the value of an outfile streamid", "streamIndex:value" },
2425 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2426 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2427 "force key frames at specified timestamps", "timestamps" },
2428 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2429 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2430 "use HW accelerated decoding", "hwaccel name" },
2431 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2432 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2433 "select a device for HW acceleration" "devicename" },
2434 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2435 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2436 "automatically insert correct rotate filters" },
2439 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2440 "set the number of audio frames to record", "number" },
2441 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2442 "set audio quality (codec-specific)", "quality", },
2443 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2444 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2445 "set audio sampling rate (in Hz)", "rate" },
2446 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2447 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2448 "set number of audio channels", "channels" },
2449 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2451 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2452 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2453 "force audio codec ('copy' to copy stream)", "codec" },
2454 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2455 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2456 "force audio tag/fourcc", "fourcc/tag" },
2457 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2458 "change audio volume (256=normal)" , "volume" },
2459 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2460 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2461 "set sample format", "format" },
2462 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2463 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2464 "set channel layout", "layout" },
2465 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2466 "audio filters", "filter list" },
2468 /* subtitle options */
2469 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2470 "disable subtitle" },
2471 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2472 "force subtitle codec ('copy' to copy stream)", "codec" },
2473 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2474 , "force subtitle tag/fourcc", "fourcc/tag" },
2477 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2480 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2481 "set the maximum demux-decode delay", "seconds" },
2482 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2483 "set the initial demux-decode delay", "seconds" },
2485 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2486 "A comma-separated list of bitstream filters", "bitstream_filters" },
2488 /* data codec support */
2489 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2490 "force data codec ('copy' to copy stream)", "codec" },