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 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
63 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
67 int hwaccel_lax_profile_check = 0;
68 AVBufferRef *hw_device_ctx;
69 HWDevice *filter_hw_device;
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 show_hwaccels(void *optctx, const char *opt, const char *arg)
182 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
185 printf("Supported hardware acceleration:\n");
186 while ((type = av_hwdevice_iterate_types(type)) !=
187 AV_HWDEVICE_TYPE_NONE)
188 printf("%s\n", av_hwdevice_get_type_name(type));
189 for (i = 0; hwaccels[i].name; i++)
190 printf("%s\n", hwaccels[i].name);
195 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:a", arg, options);
201 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:v", arg, options);
207 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:s", arg, options);
213 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:d", arg, options);
219 static int opt_map(void *optctx, const char *opt, const char *arg)
221 OptionsContext *o = optctx;
223 int i, negative = 0, file_idx;
224 int sync_file_idx = -1, sync_stream_idx;
232 map = av_strdup(arg);
234 return AVERROR(ENOMEM);
236 /* parse sync stream first, just pick first matching stream */
237 if (sync = strchr(map, ',')) {
239 sync_file_idx = strtol(sync + 1, &sync, 0);
240 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
246 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
247 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
248 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
252 if (i == input_files[sync_file_idx]->nb_streams) {
253 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
254 "match any streams.\n", arg);
261 /* this mapping refers to lavfi output */
262 const char *c = map + 1;
263 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
264 m = &o->stream_maps[o->nb_stream_maps - 1];
265 m->linklabel = av_get_token(&c, "]");
267 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
271 file_idx = strtol(map, &p, 0);
272 if (file_idx >= nb_input_files || file_idx < 0) {
273 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
277 /* disable some already defined maps */
278 for (i = 0; i < o->nb_stream_maps; i++) {
279 m = &o->stream_maps[i];
280 if (file_idx == m->file_index &&
281 check_stream_specifier(input_files[m->file_index]->ctx,
282 input_files[m->file_index]->ctx->streams[m->stream_index],
283 *p == ':' ? p + 1 : p) > 0)
287 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
288 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
289 *p == ':' ? p + 1 : p) <= 0)
291 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
292 m = &o->stream_maps[o->nb_stream_maps - 1];
294 m->file_index = file_idx;
297 if (sync_file_idx >= 0) {
298 m->sync_file_index = sync_file_idx;
299 m->sync_stream_index = sync_stream_idx;
301 m->sync_file_index = file_idx;
302 m->sync_stream_index = i;
308 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
316 static int opt_attach(void *optctx, const char *opt, const char *arg)
318 OptionsContext *o = optctx;
319 GROW_ARRAY(o->attachments, o->nb_attachments);
320 o->attachments[o->nb_attachments - 1] = arg;
325 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
328 const char *prefix = "vaapi:";
331 tmp = av_malloc(strlen(prefix) + strlen(arg) + 1);
333 return AVERROR(ENOMEM);
336 err = hw_device_init_from_string(tmp, &dev);
340 hw_device_ctx = av_buffer_ref(dev->device_ref);
342 return AVERROR(ENOMEM);
347 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
349 if (!strcmp(arg, "list")) {
350 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
351 printf("Supported hardware device types:\n");
352 while ((type = av_hwdevice_iterate_types(type)) !=
353 AV_HWDEVICE_TYPE_NONE)
354 printf("%s\n", av_hwdevice_get_type_name(type));
358 return hw_device_init_from_string(arg, NULL);
362 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
364 if (filter_hw_device) {
365 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
366 return AVERROR(EINVAL);
368 filter_hw_device = hw_device_get_by_name(arg);
369 if (!filter_hw_device) {
370 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
371 return AVERROR(EINVAL);
377 * Parse a metadata specifier passed as 'arg' parameter.
378 * @param arg metadata string to parse
379 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
380 * @param index for type c/p, chapter/program index is written here
381 * @param stream_spec for type s, the stream specifier is written here
383 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
391 if (*(++arg) && *arg != ':') {
392 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
395 *stream_spec = *arg == ':' ? arg + 1 : "";
400 *index = strtol(++arg, NULL, 0);
403 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
410 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
412 AVDictionary **meta_in = NULL;
413 AVDictionary **meta_out;
415 char type_in, type_out;
416 const char *istream_spec = NULL, *ostream_spec = NULL;
417 int idx_in = 0, idx_out = 0;
419 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
420 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
422 if (type_in == 'g' || type_out == 'g')
423 o->metadata_global_manual = 1;
424 if (type_in == 's' || type_out == 's')
425 o->metadata_streams_manual = 1;
426 if (type_in == 'c' || type_out == 'c')
427 o->metadata_chapters_manual = 1;
429 /* ic is NULL when just disabling automatic mappings */
433 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
434 if ((index) < 0 || (index) >= (nb_elems)) {\
435 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
440 #define SET_DICT(type, meta, context, index)\
443 meta = &context->metadata;\
446 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
447 meta = &context->chapters[index]->metadata;\
450 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
451 meta = &context->programs[index]->metadata;\
454 break; /* handled separately below */ \
455 default: av_assert0(0);\
458 SET_DICT(type_in, meta_in, ic, idx_in);
459 SET_DICT(type_out, meta_out, oc, idx_out);
461 /* for input streams choose first matching stream */
462 if (type_in == 's') {
463 for (i = 0; i < ic->nb_streams; i++) {
464 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
465 meta_in = &ic->streams[i]->metadata;
471 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
476 if (type_out == 's') {
477 for (i = 0; i < oc->nb_streams; i++) {
478 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
479 meta_out = &oc->streams[i]->metadata;
480 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
485 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
490 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
492 const AVCodecDescriptor *desc;
493 const char *codec_string = encoder ? "encoder" : "decoder";
497 avcodec_find_encoder_by_name(name) :
498 avcodec_find_decoder_by_name(name);
500 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
501 codec = encoder ? avcodec_find_encoder(desc->id) :
502 avcodec_find_decoder(desc->id);
504 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
505 codec_string, codec->name, desc->name);
509 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
512 if (codec->type != type) {
513 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
519 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
521 char *codec_name = NULL;
523 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
525 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
526 st->codecpar->codec_id = codec->id;
529 return avcodec_find_decoder(st->codecpar->codec_id);
532 /* Add all the streams from the given input file to the global
533 * list of input streams. */
534 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
538 for (i = 0; i < ic->nb_streams; i++) {
539 AVStream *st = ic->streams[i];
540 AVCodecParameters *par = st->codecpar;
541 InputStream *ist = av_mallocz(sizeof(*ist));
542 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
543 char *hwaccel_output_format = NULL;
544 char *codec_tag = NULL;
550 GROW_ARRAY(input_streams, nb_input_streams);
551 input_streams[nb_input_streams - 1] = ist;
554 ist->file_index = nb_input_files;
556 st->discard = AVDISCARD_ALL;
558 ist->min_pts = INT64_MAX;
559 ist->max_pts = INT64_MIN;
562 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
565 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
567 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
569 uint32_t tag = strtol(codec_tag, &next, 0);
571 tag = AV_RL32(codec_tag);
572 st->codecpar->codec_tag = tag;
575 ist->dec = choose_decoder(o, ic, st);
576 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
578 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
580 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
584 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
586 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
590 switch (par->codec_type) {
591 case AVMEDIA_TYPE_VIDEO:
592 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
593 if (framerate && av_parse_video_rate(&ist->framerate,
595 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
600 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
602 if (!strcmp(hwaccel, "none"))
603 ist->hwaccel_id = HWACCEL_NONE;
604 else if (!strcmp(hwaccel, "auto"))
605 ist->hwaccel_id = HWACCEL_AUTO;
607 enum AVHWDeviceType type;
609 for (i = 0; hwaccels[i].name; i++) {
610 if (!strcmp(hwaccels[i].name, hwaccel)) {
611 ist->hwaccel_id = hwaccels[i].id;
616 if (!ist->hwaccel_id) {
617 type = av_hwdevice_find_type_by_name(hwaccel);
618 if (type != AV_HWDEVICE_TYPE_NONE) {
619 ist->hwaccel_id = HWACCEL_GENERIC;
620 ist->hwaccel_device_type = type;
624 if (!ist->hwaccel_id) {
625 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
627 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
628 type = AV_HWDEVICE_TYPE_NONE;
629 while ((type = av_hwdevice_iterate_types(type)) !=
630 AV_HWDEVICE_TYPE_NONE)
631 av_log(NULL, AV_LOG_FATAL, "%s ",
632 av_hwdevice_get_type_name(type));
633 for (i = 0; hwaccels[i].name; i++)
634 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
635 av_log(NULL, AV_LOG_FATAL, "\n");
641 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
642 if (hwaccel_device) {
643 ist->hwaccel_device = av_strdup(hwaccel_device);
644 if (!ist->hwaccel_device)
648 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
649 hwaccel_output_format, ic, st);
650 if (hwaccel_output_format) {
651 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
652 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
653 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
654 "format: %s", hwaccel_output_format);
657 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
660 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
663 case AVMEDIA_TYPE_AUDIO:
664 guess_input_channel_layout(ist);
666 case AVMEDIA_TYPE_DATA:
667 case AVMEDIA_TYPE_SUBTITLE:
668 case AVMEDIA_TYPE_ATTACHMENT:
669 case AVMEDIA_TYPE_UNKNOWN:
677 static void assert_file_overwrite(const char *filename)
679 if (file_overwrite && file_skip) {
680 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
684 if (!file_overwrite &&
685 (!strchr(filename, ':') || filename[1] == ':' ||
686 av_strstart(filename, "file:", NULL))) {
687 if (avio_check(filename, 0) == 0) {
688 if (!using_stdin && !file_skip) {
689 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
692 fprintf(stderr, "Not overwriting - exiting\n");
697 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
704 static void dump_attachment(AVStream *st, const char *filename)
707 AVIOContext *out = NULL;
708 AVDictionaryEntry *e;
710 if (!st->codecpar->extradata_size) {
711 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
712 nb_input_files - 1, st->index);
715 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
718 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
719 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
723 assert_file_overwrite(filename);
725 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
726 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
731 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
736 static int open_input_file(OptionsContext *o, const char *filename)
740 AVInputFormat *file_iformat = NULL;
745 AVDictionary *unused_opts = NULL;
746 AVDictionaryEntry *e = NULL;
747 int orig_nb_streams; // number of streams before avformat_find_stream_info
750 if (!(file_iformat = av_find_input_format(o->format))) {
751 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
756 if (!strcmp(filename, "-"))
759 using_stdin |= !strncmp(filename, "pipe:", 5) ||
760 !strcmp(filename, "/dev/stdin");
762 /* get default parameters from command line */
763 ic = avformat_alloc_context();
765 print_error(filename, AVERROR(ENOMEM));
768 if (o->nb_audio_sample_rate) {
769 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
770 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
772 if (o->nb_audio_channels) {
773 /* because we set audio_channels based on both the "ac" and
774 * "channel_layout" options, we need to check that the specified
775 * demuxer actually has the "channels" option before setting it */
776 if (file_iformat && file_iformat->priv_class &&
777 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
778 AV_OPT_SEARCH_FAKE_OBJ)) {
779 snprintf(buf, sizeof(buf), "%d",
780 o->audio_channels[o->nb_audio_channels - 1].u.i);
781 av_dict_set(&o->g->format_opts, "channels", buf, 0);
784 if (o->nb_frame_rates) {
785 /* set the format-level framerate option;
786 * this is important for video grabbers, e.g. x11 */
787 if (file_iformat && file_iformat->priv_class &&
788 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
789 AV_OPT_SEARCH_FAKE_OBJ)) {
790 av_dict_set(&o->g->format_opts, "framerate",
791 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
794 if (o->nb_frame_sizes) {
795 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
797 if (o->nb_frame_pix_fmts)
798 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
800 ic->flags |= AVFMT_FLAG_NONBLOCK;
801 ic->interrupt_callback = int_cb;
803 /* open the input file with generic Libav function */
804 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
806 print_error(filename, err);
809 assert_avoptions(o->g->format_opts);
811 /* apply forced codec ids */
812 for (i = 0; i < ic->nb_streams; i++)
813 choose_decoder(o, ic, ic->streams[i]);
815 /* Set AVCodecContext options for avformat_find_stream_info */
816 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
817 orig_nb_streams = ic->nb_streams;
819 /* If not enough info to get the stream parameters, we decode the
820 first frames to get it. (used in mpeg case for example) */
821 ret = avformat_find_stream_info(ic, opts);
823 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
824 avformat_close_input(&ic);
828 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
829 /* add the stream start time */
830 if (ic->start_time != AV_NOPTS_VALUE)
831 timestamp += ic->start_time;
833 /* if seeking requested, we execute it */
834 if (o->start_time != AV_NOPTS_VALUE) {
835 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
837 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
838 filename, (double)timestamp / AV_TIME_BASE);
842 /* update the current parameters so that they match the one of the input stream */
843 add_input_streams(o, ic);
845 /* dump the file content */
846 av_dump_format(ic, nb_input_files, filename, 0);
848 GROW_ARRAY(input_files, nb_input_files);
849 f = av_mallocz(sizeof(*f));
852 input_files[nb_input_files - 1] = f;
855 f->ist_index = nb_input_streams - ic->nb_streams;
856 f->start_time = o->start_time;
857 f->recording_time = o->recording_time;
858 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
859 f->nb_streams = ic->nb_streams;
860 f->rate_emu = o->rate_emu;
861 f->accurate_seek = o->accurate_seek;
864 f->time_base = (AVRational){ 1, 1 };
866 /* check if all codec options have been used */
867 unused_opts = strip_specifiers(o->g->codec_opts);
868 for (i = f->ist_index; i < nb_input_streams; i++) {
870 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
871 AV_DICT_IGNORE_SUFFIX)))
872 av_dict_set(&unused_opts, e->key, NULL, 0);
876 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
877 const AVClass *class = avcodec_get_class();
878 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
879 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
882 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
883 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
884 "input file #%d (%s) is not a decoding option.\n", e->key,
885 option->help ? option->help : "", nb_input_files - 1,
890 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
891 "input file #%d (%s) has not been used for any stream. The most "
892 "likely reason is either wrong type (e.g. a video option with "
893 "no video streams) or that it is a private option of some decoder "
894 "which was not actually used for any stream.\n", e->key,
895 option->help ? option->help : "", nb_input_files - 1, filename);
897 av_dict_free(&unused_opts);
899 for (i = 0; i < o->nb_dump_attachment; i++) {
902 for (j = 0; j < ic->nb_streams; j++) {
903 AVStream *st = ic->streams[j];
905 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
906 dump_attachment(st, o->dump_attachment[i].u.str);
910 for (i = 0; i < orig_nb_streams; i++)
911 av_dict_free(&opts[i]);
917 static uint8_t *get_line(AVIOContext *s)
923 if (avio_open_dyn_buf(&line) < 0) {
924 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
928 while ((c = avio_r8(s)) && c != '\n')
931 avio_close_dyn_buf(line, &buf);
936 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
940 const char *base[3] = { getenv("AVCONV_DATADIR"),
945 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
949 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
950 i != 1 ? "" : "/.avconv", codec_name, preset_name);
951 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
954 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
955 i != 1 ? "" : "/.avconv", preset_name);
956 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
962 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
964 enum AVMediaType type = ost->st->codecpar->codec_type;
965 char *codec_name = NULL;
967 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
968 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
970 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
971 NULL, ost->st->codecpar->codec_type);
972 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
974 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
975 "output stream #%d:%d. Default encoder for format %s is "
976 "probably disabled. Please choose an encoder manually.\n",
977 ost->file_index, ost->index, s->oformat->name);
978 return AVERROR_ENCODER_NOT_FOUND;
980 } else if (!strcmp(codec_name, "copy"))
981 ost->stream_copy = 1;
983 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
984 ost->st->codecpar->codec_id = ost->enc->id;
987 ost->encoding_needed = !ost->stream_copy;
989 /* no encoding supported for other media types */
990 ost->stream_copy = 1;
991 ost->encoding_needed = 0;
997 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
1000 AVStream *st = avformat_new_stream(oc, NULL);
1001 int idx = oc->nb_streams - 1, ret = 0;
1002 const char *bsfs = NULL;
1003 char *next, *codec_tag = NULL;
1008 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1012 if (oc->nb_streams - 1 < o->nb_streamid_map)
1013 st->id = o->streamid_map[oc->nb_streams - 1];
1015 GROW_ARRAY(output_streams, nb_output_streams);
1016 if (!(ost = av_mallocz(sizeof(*ost))))
1018 output_streams[nb_output_streams - 1] = ost;
1020 ost->file_index = nb_output_files - 1;
1023 st->codecpar->codec_type = type;
1025 ret = choose_encoder(o, oc, ost);
1027 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1028 "%d:%d\n", ost->file_index, ost->index);
1032 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1033 if (!ost->enc_ctx) {
1034 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1037 ost->enc_ctx->codec_type = type;
1040 AVIOContext *s = NULL;
1041 char *buf = NULL, *arg = NULL, *preset = NULL;
1043 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1045 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1046 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1049 if (!buf[0] || buf[0] == '#') {
1053 if (!(arg = strchr(buf, '='))) {
1054 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1058 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1060 } while (!s->eof_reached);
1064 av_log(NULL, AV_LOG_FATAL,
1065 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1066 preset, ost->file_index, ost->index);
1070 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1073 ost->max_frames = INT64_MAX;
1074 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1076 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1077 while (bsfs && *bsfs) {
1078 const AVBitStreamFilter *filter;
1079 const char *bsf, *bsf_options_str, *bsf_name;
1080 AVDictionary *bsf_options = NULL;
1082 bsf = bsf_options_str = av_get_token(&bsfs, ",");
1085 bsf_name = av_get_token(&bsf_options_str, "=");
1089 filter = av_bsf_get_by_name(bsf_name);
1091 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1094 if (*bsf_options_str++) {
1095 ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
1097 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1103 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1104 ost->nb_bitstream_filters + 1,
1105 sizeof(*ost->bsf_ctx));
1109 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1111 av_log(NULL, AV_LOG_ERROR, "Error allocating a bistream filter context\n");
1114 ost->nb_bitstream_filters++;
1117 ret = av_opt_set_dict(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, &bsf_options);
1119 av_log(NULL, AV_LOG_ERROR, "Error setting options for bitstream filter %s\n", bsf_name);
1122 assert_avoptions(bsf_options);
1123 av_dict_free(&bsf_options);
1125 av_freep(&bsf_name);
1131 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1133 uint32_t tag = strtol(codec_tag, &next, 0);
1135 tag = AV_RL32(codec_tag);
1136 ost->enc_ctx->codec_tag = tag;
1139 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1141 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1142 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1145 MATCH_PER_STREAM_OPT(bitrates, i, bitrate, oc, st);
1147 if (ost->stream_copy)
1148 ost->bitrate_override = bitrate;
1150 ost->enc_ctx->bit_rate = bitrate;
1153 ost->max_muxing_queue_size = 128;
1154 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1155 ost->max_muxing_queue_size *= sizeof(AVPacket);
1157 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1158 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1160 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1162 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1164 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1165 ost->last_mux_dts = AV_NOPTS_VALUE;
1167 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1168 if (!ost->muxing_queue)
1174 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1177 const char *p = str;
1184 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1191 /* read file contents into a string */
1192 static uint8_t *read_file(const char *filename)
1194 AVIOContext *pb = NULL;
1195 AVIOContext *dyn_buf = NULL;
1196 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1197 uint8_t buf[1024], *str;
1200 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1204 ret = avio_open_dyn_buf(&dyn_buf);
1209 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1210 avio_write(dyn_buf, buf, ret);
1211 avio_w8(dyn_buf, 0);
1214 ret = avio_close_dyn_buf(dyn_buf, &str);
1220 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1223 AVStream *st = ost->st;
1224 char *filter = NULL, *filter_script = NULL;
1226 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1227 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1229 if (filter_script && filter) {
1230 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1231 "output stream #%d:%d.\n", nb_output_files, st->index);
1236 return read_file(filter_script);
1238 return av_strdup(filter);
1240 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1244 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1248 AVCodecContext *video_enc;
1249 char *frame_aspect_ratio = NULL;
1251 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1253 video_enc = ost->enc_ctx;
1255 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1256 if (frame_aspect_ratio)
1257 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1259 if (!ost->stream_copy) {
1260 const char *p = NULL;
1261 char *frame_rate = NULL, *frame_size = NULL;
1262 char *frame_pix_fmt = NULL;
1263 char *intra_matrix = NULL, *inter_matrix = NULL;
1267 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1268 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1273 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1274 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1275 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1279 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1280 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1281 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1284 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1286 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1288 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1289 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1292 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1294 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1296 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1297 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1300 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1303 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1304 for (i = 0; p; i++) {
1306 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1308 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1311 video_enc->rc_override =
1312 av_realloc(video_enc->rc_override,
1313 sizeof(RcOverride) * (i + 1));
1314 if (!video_enc->rc_override) {
1315 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1318 video_enc->rc_override[i].start_frame = start;
1319 video_enc->rc_override[i].end_frame = end;
1321 video_enc->rc_override[i].qscale = q;
1322 video_enc->rc_override[i].quality_factor = 1.0;
1325 video_enc->rc_override[i].qscale = 0;
1326 video_enc->rc_override[i].quality_factor = -q/100.0;
1331 video_enc->rc_override_count = i;
1332 video_enc->intra_dc_precision = intra_dc_precision - 8;
1335 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1338 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1340 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1344 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1345 if (ost->logfile_prefix &&
1346 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1350 char logfilename[1024];
1353 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1354 ost->logfile_prefix ? ost->logfile_prefix :
1355 DEFAULT_PASS_LOGFILENAME_PREFIX,
1357 if (!strcmp(ost->enc->name, "libx264")) {
1358 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1360 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1361 f = fopen(logfilename, "wb");
1363 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1364 logfilename, strerror(errno));
1369 char *logbuffer = read_file(logfilename);
1372 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1376 video_enc->stats_in = logbuffer;
1381 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1382 if (ost->forced_keyframes)
1383 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1385 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1387 ost->top_field_first = -1;
1388 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1391 ost->avfilter = get_ost_filters(o, oc, ost);
1395 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1401 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1405 AVCodecContext *audio_enc;
1407 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1410 audio_enc = ost->enc_ctx;
1411 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1413 if (!ost->stream_copy) {
1414 char *sample_fmt = NULL;
1416 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1418 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1420 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1421 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1425 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1427 ost->avfilter = get_ost_filters(o, oc, ost);
1435 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1439 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1440 if (!ost->stream_copy) {
1441 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1448 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1450 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1451 ost->stream_copy = 1;
1456 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1459 AVCodecContext *subtitle_enc;
1461 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1462 subtitle_enc = ost->enc_ctx;
1464 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1469 /* arg format is "output-stream-index:streamid-value". */
1470 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1472 OptionsContext *o = optctx;
1477 av_strlcpy(idx_str, arg, sizeof(idx_str));
1478 p = strchr(idx_str, ':');
1480 av_log(NULL, AV_LOG_FATAL,
1481 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1486 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1487 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1488 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1492 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1494 AVFormatContext *is = ifile->ctx;
1495 AVFormatContext *os = ofile->ctx;
1499 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1501 return AVERROR(ENOMEM);
1504 for (i = 0; i < is->nb_chapters; i++) {
1505 AVChapter *in_ch = is->chapters[i], *out_ch;
1506 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1507 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1508 AV_TIME_BASE_Q, in_ch->time_base);
1509 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1510 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1513 if (in_ch->end < ts_off)
1515 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1518 out_ch = av_mallocz(sizeof(AVChapter));
1520 return AVERROR(ENOMEM);
1522 out_ch->id = in_ch->id;
1523 out_ch->time_base = in_ch->time_base;
1524 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1525 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1528 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1530 os->chapters[os->nb_chapters++] = out_ch;
1535 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1536 AVFormatContext *oc)
1540 switch (ofilter->type) {
1541 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1542 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1544 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1549 ost->source_index = -1;
1550 ost->filter = ofilter;
1553 ofilter->format = -1;
1555 if (ost->stream_copy) {
1556 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1557 "which is fed from a complex filtergraph. Filtering and streamcopy "
1558 "cannot be used together.\n", ost->file_index, ost->index);
1562 avfilter_inout_free(&ofilter->out_tmp);
1565 static int init_complex_filters(void)
1569 for (i = 0; i < nb_filtergraphs; i++) {
1570 ret = init_complex_filtergraph(filtergraphs[i]);
1577 static int open_output_file(OptionsContext *o, const char *filename)
1579 AVFormatContext *oc;
1581 AVOutputFormat *file_oformat;
1585 AVDictionary *unused_opts = NULL;
1586 AVDictionaryEntry *e = NULL;
1588 GROW_ARRAY(output_files, nb_output_files);
1589 of = av_mallocz(sizeof(*of));
1592 output_files[nb_output_files - 1] = of;
1594 of->ost_index = nb_output_streams;
1595 of->recording_time = o->recording_time;
1596 of->start_time = o->start_time;
1597 of->limit_filesize = o->limit_filesize;
1598 of->shortest = o->shortest;
1599 av_dict_copy(&of->opts, o->g->format_opts, 0);
1601 if (!strcmp(filename, "-"))
1604 oc = avformat_alloc_context();
1606 print_error(filename, AVERROR(ENOMEM));
1610 if (o->recording_time != INT64_MAX)
1611 oc->duration = o->recording_time;
1614 file_oformat = av_guess_format(o->format, NULL, NULL);
1615 if (!file_oformat) {
1616 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1620 file_oformat = av_guess_format(NULL, filename, NULL);
1621 if (!file_oformat) {
1622 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1628 oc->oformat = file_oformat;
1629 oc->interrupt_callback = int_cb;
1630 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1632 /* create streams for all unlabeled output pads */
1633 for (i = 0; i < nb_filtergraphs; i++) {
1634 FilterGraph *fg = filtergraphs[i];
1635 for (j = 0; j < fg->nb_outputs; j++) {
1636 OutputFilter *ofilter = fg->outputs[j];
1638 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1641 switch (ofilter->type) {
1642 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1643 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1644 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1646 init_output_filter(ofilter, o, oc);
1650 if (!o->nb_stream_maps) {
1651 /* pick the "best" stream of each type */
1652 #define NEW_STREAM(type, index)\
1654 ost = new_ ## type ## _stream(o, oc);\
1655 ost->source_index = index;\
1656 ost->sync_ist = input_streams[index];\
1657 input_streams[index]->discard = 0;\
1658 input_streams[index]->st->discard = AVDISCARD_NONE;\
1661 /* video: highest resolution */
1662 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1663 int area = 0, idx = -1;
1664 for (i = 0; i < nb_input_streams; i++) {
1665 ist = input_streams[i];
1666 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1667 ist->st->codecpar->width * ist->st->codecpar->height > area) {
1668 area = ist->st->codecpar->width * ist->st->codecpar->height;
1672 NEW_STREAM(video, idx);
1675 /* audio: most channels */
1676 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1677 int channels = 0, idx = -1;
1678 for (i = 0; i < nb_input_streams; i++) {
1679 ist = input_streams[i];
1680 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1681 ist->st->codecpar->channels > channels) {
1682 channels = ist->st->codecpar->channels;
1686 NEW_STREAM(audio, idx);
1689 /* subtitles: pick first */
1690 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1691 for (i = 0; i < nb_input_streams; i++)
1692 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1693 NEW_STREAM(subtitle, i);
1697 /* do something with data? */
1699 for (i = 0; i < o->nb_stream_maps; i++) {
1700 StreamMap *map = &o->stream_maps[i];
1705 if (map->linklabel) {
1707 OutputFilter *ofilter = NULL;
1710 for (j = 0; j < nb_filtergraphs; j++) {
1711 fg = filtergraphs[j];
1712 for (k = 0; k < fg->nb_outputs; k++) {
1713 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1714 if (out && !strcmp(out->name, map->linklabel)) {
1715 ofilter = fg->outputs[k];
1722 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1723 "in any defined filter graph.\n", map->linklabel);
1726 init_output_filter(ofilter, o, oc);
1728 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1729 switch (ist->st->codecpar->codec_type) {
1730 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1731 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1732 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1733 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1734 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1736 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1737 map->file_index, map->stream_index);
1741 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1742 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1743 map->sync_stream_index];
1745 ist->st->discard = AVDISCARD_NONE;
1750 /* handle attached files */
1751 for (i = 0; i < o->nb_attachments; i++) {
1753 uint8_t *attachment;
1757 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1758 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1762 if ((len = avio_size(pb)) <= 0) {
1763 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1767 if (!(attachment = av_malloc(len))) {
1768 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1772 avio_read(pb, attachment, len);
1774 ost = new_attachment_stream(o, oc);
1775 ost->stream_copy = 0;
1776 ost->source_index = -1;
1777 ost->attachment_filename = o->attachments[i];
1778 ost->st->codecpar->extradata = attachment;
1779 ost->st->codecpar->extradata_size = len;
1781 p = strrchr(o->attachments[i], '/');
1782 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1786 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1787 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1788 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1792 /* check if all codec options have been used */
1793 unused_opts = strip_specifiers(o->g->codec_opts);
1794 for (i = of->ost_index; i < nb_output_streams; i++) {
1796 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1797 AV_DICT_IGNORE_SUFFIX)))
1798 av_dict_set(&unused_opts, e->key, NULL, 0);
1802 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1803 const AVClass *class = avcodec_get_class();
1804 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1805 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1808 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1809 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1810 "output file #%d (%s) is not an encoding option.\n", e->key,
1811 option->help ? option->help : "", nb_output_files - 1,
1816 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1817 "output file #%d (%s) has not been used for any stream. The most "
1818 "likely reason is either wrong type (e.g. a video option with "
1819 "no video streams) or that it is a private option of some encoder "
1820 "which was not actually used for any stream.\n", e->key,
1821 option->help ? option->help : "", nb_output_files - 1, filename);
1823 av_dict_free(&unused_opts);
1825 /* set the decoding_needed flags and create simple filtergraphs */
1826 for (i = of->ost_index; i < nb_output_streams; i++) {
1827 OutputStream *ost = output_streams[i];
1829 if (ost->encoding_needed && ost->source_index >= 0) {
1830 InputStream *ist = input_streams[ost->source_index];
1831 ist->decoding_needed = 1;
1833 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1834 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1835 err = init_simple_filtergraph(ist, ost);
1837 av_log(NULL, AV_LOG_ERROR,
1838 "Error initializing a simple filtergraph between streams "
1839 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1840 nb_output_files - 1, ost->st->index);
1847 * We want CFR output if and only if one of those is true:
1848 * 1) user specified output framerate with -r
1849 * 2) user specified -vsync cfr
1850 * 3) output format is CFR and the user didn't force vsync to
1851 * something else than CFR
1853 * in such a case, set ost->frame_rate
1855 if (ost->encoding_needed && ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1856 int format_cfr = !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS));
1857 int need_cfr = !!ost->frame_rate.num;
1859 if (video_sync_method == VSYNC_CFR ||
1860 (video_sync_method == VSYNC_AUTO && format_cfr))
1863 if (need_cfr && !ost->frame_rate.num) {
1864 InputStream *ist = ost->source_index >= 0 ? input_streams[ost->source_index] : NULL;
1866 if (ist && ist->framerate.num)
1867 ost->frame_rate = ist->framerate;
1868 else if (ist && ist->st->avg_frame_rate.num)
1869 ost->frame_rate = ist->st->avg_frame_rate;
1871 av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1872 "for the output stream #%d:%d, but no information "
1873 "about the input framerate is available. Falling "
1874 "back to a default value of 25fps. Use the -r option "
1875 "if you want a different framerate.\n",
1876 ost->file_index, ost->index);
1877 ost->frame_rate = (AVRational){ 25, 1 };
1881 if (need_cfr && ost->enc->supported_framerates && !ost->force_fps) {
1882 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1883 ost->frame_rate = ost->enc->supported_framerates[idx];
1887 /* set the filter output constraints */
1889 OutputFilter *f = ost->filter;
1891 switch (ost->enc_ctx->codec_type) {
1892 case AVMEDIA_TYPE_VIDEO:
1893 f->frame_rate = ost->frame_rate;
1894 f->width = ost->enc_ctx->width;
1895 f->height = ost->enc_ctx->height;
1896 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
1897 f->format = ost->enc_ctx->pix_fmt;
1898 } else if (ost->enc->pix_fmts) {
1900 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
1902 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1905 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
1908 case AVMEDIA_TYPE_AUDIO:
1909 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
1910 f->format = ost->enc_ctx->sample_fmt;
1911 } else if (ost->enc->sample_fmts) {
1913 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
1915 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1918 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
1920 if (ost->enc_ctx->sample_rate) {
1921 f->sample_rate = ost->enc_ctx->sample_rate;
1922 } else if (ost->enc->supported_samplerates) {
1924 while (ost->enc->supported_samplerates[count])
1926 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
1927 if (!f->sample_rates)
1929 memcpy(f->sample_rates, ost->enc->supported_samplerates,
1930 (count + 1) * sizeof(*f->sample_rates));
1932 if (ost->enc_ctx->channels) {
1933 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
1934 } else if (ost->enc->channel_layouts) {
1936 while (ost->enc->channel_layouts[count])
1938 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
1939 if (!f->channel_layouts)
1941 memcpy(f->channel_layouts, ost->enc->channel_layouts,
1942 (count + 1) * sizeof(*f->channel_layouts));
1950 /* check filename in case of an image number is expected */
1951 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1952 if (!av_filename_number_test(oc->filename)) {
1953 print_error(oc->filename, AVERROR(EINVAL));
1958 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1959 /* test if it already exists to avoid losing precious files */
1960 assert_file_overwrite(filename);
1963 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1964 &oc->interrupt_callback,
1966 print_error(filename, err);
1971 if (o->mux_preload) {
1973 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1974 av_dict_set(&of->opts, "preload", buf, 0);
1976 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1977 oc->flags |= AVFMT_FLAG_NONBLOCK;
1980 for (i = 0; i < o->nb_metadata_map; i++) {
1982 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1984 if (in_file_index >= nb_input_files) {
1985 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1988 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1989 in_file_index >= 0 ?
1990 input_files[in_file_index]->ctx : NULL, o);
1994 if (o->chapters_input_file >= nb_input_files) {
1995 if (o->chapters_input_file == INT_MAX) {
1996 /* copy chapters from the first input file that has them*/
1997 o->chapters_input_file = -1;
1998 for (i = 0; i < nb_input_files; i++)
1999 if (input_files[i]->ctx->nb_chapters) {
2000 o->chapters_input_file = i;
2004 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2005 o->chapters_input_file);
2009 if (o->chapters_input_file >= 0)
2010 copy_chapters(input_files[o->chapters_input_file], of,
2011 !o->metadata_chapters_manual);
2013 /* copy global metadata by default */
2014 if (!o->metadata_global_manual && nb_input_files)
2015 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2016 AV_DICT_DONT_OVERWRITE);
2017 if (!o->metadata_streams_manual)
2018 for (i = of->ost_index; i < nb_output_streams; i++) {
2020 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2022 ist = input_streams[output_streams[i]->source_index];
2023 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2026 /* process manually set metadata */
2027 for (i = 0; i < o->nb_metadata; i++) {
2030 const char *stream_spec;
2031 int index = 0, j, ret;
2033 val = strchr(o->metadata[i].u.str, '=');
2035 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2036 o->metadata[i].u.str);
2041 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2043 for (j = 0; j < oc->nb_streams; j++) {
2044 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2045 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2056 if (index < 0 || index >= oc->nb_chapters) {
2057 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2060 m = &oc->chapters[index]->metadata;
2063 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2066 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2073 static int opt_target(void *optctx, const char *opt, const char *arg)
2075 OptionsContext *o = optctx;
2076 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2077 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2079 if (!strncmp(arg, "pal-", 4)) {
2082 } else if (!strncmp(arg, "ntsc-", 5)) {
2085 } else if (!strncmp(arg, "film-", 5)) {
2089 /* Try to determine PAL/NTSC by peeking in the input files */
2090 if (nb_input_files) {
2092 for (j = 0; j < nb_input_files; j++) {
2093 for (i = 0; i < input_files[j]->nb_streams; i++) {
2094 AVStream *st = input_files[j]->ctx->streams[i];
2095 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2097 fr = st->time_base.den * 1000 / st->time_base.num;
2101 } else if ((fr == 29970) || (fr == 23976)) {
2106 if (norm != UNKNOWN)
2110 if (norm != UNKNOWN)
2111 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2114 if (norm == UNKNOWN) {
2115 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2116 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2117 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2121 if (!strcmp(arg, "vcd")) {
2122 opt_video_codec(o, "c:v", "mpeg1video");
2123 opt_audio_codec(o, "c:a", "mp2");
2124 parse_option(o, "f", "vcd", options);
2126 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2127 parse_option(o, "r", frame_rates[norm], options);
2128 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2130 opt_default(NULL, "b", "1150000");
2131 opt_default(NULL, "maxrate", "1150000");
2132 opt_default(NULL, "minrate", "1150000");
2133 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2135 opt_default(NULL, "b:a", "224000");
2136 parse_option(o, "ar", "44100", options);
2137 parse_option(o, "ac", "2", options);
2139 opt_default(NULL, "packetsize", "2324");
2140 opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
2142 /* We have to offset the PTS, so that it is consistent with the SCR.
2143 SCR starts at 36000, but the first two packs contain only padding
2144 and the first pack from the other stream, respectively, may also have
2145 been written before.
2146 So the real data starts at SCR 36000+3*1200. */
2147 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2148 } else if (!strcmp(arg, "svcd")) {
2150 opt_video_codec(o, "c:v", "mpeg2video");
2151 opt_audio_codec(o, "c:a", "mp2");
2152 parse_option(o, "f", "svcd", options);
2154 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2155 parse_option(o, "r", frame_rates[norm], options);
2156 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2158 opt_default(NULL, "b", "2040000");
2159 opt_default(NULL, "maxrate", "2516000");
2160 opt_default(NULL, "minrate", "0"); // 1145000;
2161 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2162 opt_default(NULL, "scan_offset", "1");
2165 opt_default(NULL, "b:a", "224000");
2166 parse_option(o, "ar", "44100", options);
2168 opt_default(NULL, "packetsize", "2324");
2170 } else if (!strcmp(arg, "dvd")) {
2172 opt_video_codec(o, "c:v", "mpeg2video");
2173 opt_audio_codec(o, "c:a", "ac3");
2174 parse_option(o, "f", "dvd", options);
2176 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2177 parse_option(o, "r", frame_rates[norm], options);
2178 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2180 opt_default(NULL, "b", "6000000");
2181 opt_default(NULL, "maxrate", "9000000");
2182 opt_default(NULL, "minrate", "0"); // 1500000;
2183 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2185 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2186 opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2188 opt_default(NULL, "b:a", "448000");
2189 parse_option(o, "ar", "48000", options);
2191 } else if (!strncmp(arg, "dv", 2)) {
2193 parse_option(o, "f", "dv", options);
2195 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2196 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2197 norm == PAL ? "yuv420p" : "yuv411p", options);
2198 parse_option(o, "r", frame_rates[norm], options);
2200 parse_option(o, "ar", "48000", options);
2201 parse_option(o, "ac", "2", options);
2204 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2205 return AVERROR(EINVAL);
2208 av_dict_copy(&o->g->codec_opts, codec_opts, 0);
2209 av_dict_copy(&o->g->format_opts, format_opts, 0);
2214 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2216 av_free (vstats_filename);
2217 vstats_filename = av_strdup (arg);
2221 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2224 time_t today2 = time(NULL);
2225 struct tm *today = localtime(&today2);
2227 if (!today) { // maybe tomorrow
2228 av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2232 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2234 return opt_vstats_file(NULL, opt, filename);
2237 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2239 OptionsContext *o = optctx;
2240 return parse_option(o, "frames:v", arg, options);
2243 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2245 OptionsContext *o = optctx;
2246 return parse_option(o, "frames:a", arg, options);
2249 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2251 OptionsContext *o = optctx;
2252 return parse_option(o, "frames:d", arg, options);
2255 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2257 OptionsContext *o = optctx;
2258 return parse_option(o, "tag:v", arg, options);
2261 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2263 OptionsContext *o = optctx;
2264 return parse_option(o, "tag:a", arg, options);
2267 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2269 OptionsContext *o = optctx;
2270 return parse_option(o, "tag:s", arg, options);
2273 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2275 OptionsContext *o = optctx;
2276 return parse_option(o, "filter:v", arg, options);
2279 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2281 OptionsContext *o = optctx;
2282 return parse_option(o, "filter:a", arg, options);
2285 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2287 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2288 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2289 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2291 if (video_sync_method == VSYNC_AUTO)
2292 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2296 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2298 OptionsContext *o = optctx;
2299 char layout_str[32];
2302 int ret, channels, ac_str_size;
2305 layout = av_get_channel_layout(arg);
2307 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2308 return AVERROR(EINVAL);
2310 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2311 ret = opt_default(NULL, opt, layout_str);
2315 /* set 'ac' option based on channel layout */
2316 channels = av_get_channel_layout_nb_channels(layout);
2317 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2318 stream_str = strchr(opt, ':');
2319 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2320 ac_str = av_mallocz(ac_str_size);
2322 return AVERROR(ENOMEM);
2323 av_strlcpy(ac_str, "ac", 3);
2325 av_strlcat(ac_str, stream_str, ac_str_size);
2326 ret = parse_option(o, ac_str, layout_str, options);
2332 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2334 OptionsContext *o = optctx;
2335 return parse_option(o, "q:a", arg, options);
2338 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2340 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2341 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2342 return AVERROR(ENOMEM);
2343 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2344 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2345 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2346 return AVERROR(ENOMEM);
2350 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2352 uint8_t *graph_desc = read_file(arg);
2354 return AVERROR(EINVAL);
2356 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2357 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2358 return AVERROR(ENOMEM);
2359 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2360 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2364 void show_help_default(const char *opt, const char *arg)
2366 /* per-file options have at least one of those set */
2367 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2368 int show_advanced = 0, show_avoptions = 0;
2371 if (!strcmp(opt, "long"))
2373 else if (!strcmp(opt, "full"))
2374 show_advanced = show_avoptions = 1;
2376 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2381 printf("Getting help:\n"
2382 " -h -- print basic options\n"
2383 " -h long -- print more options\n"
2384 " -h full -- print all options (including all format and codec specific options, very long)\n"
2385 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2386 " See man %s for detailed description of the options.\n"
2387 "\n", program_name);
2389 show_help_options(options, "Print help / information / capabilities:",
2392 show_help_options(options, "Global options (affect whole program "
2393 "instead of just one file:",
2394 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2396 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2397 per_file | OPT_EXIT, 0);
2399 show_help_options(options, "Per-file main options:", 0,
2400 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2401 OPT_EXIT, per_file);
2403 show_help_options(options, "Advanced per-file options:",
2404 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2406 show_help_options(options, "Video options:",
2407 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2409 show_help_options(options, "Advanced Video options:",
2410 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2412 show_help_options(options, "Audio options:",
2413 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2415 show_help_options(options, "Advanced Audio options:",
2416 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2417 show_help_options(options, "Subtitle options:",
2418 OPT_SUBTITLE, 0, 0);
2421 if (show_avoptions) {
2422 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2423 show_help_children(avcodec_get_class(), flags);
2424 show_help_children(avformat_get_class(), flags);
2425 show_help_children(sws_get_class(), flags);
2426 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2430 void show_usage(void)
2432 printf("Hyper fast Audio and Video encoder\n");
2433 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2442 static const OptionGroupDef groups[] = {
2443 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2444 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2447 static int open_files(OptionGroupList *l, const char *inout,
2448 int (*open_file)(OptionsContext*, const char*))
2452 for (i = 0; i < l->nb_groups; i++) {
2453 OptionGroup *g = &l->groups[i];
2459 ret = parse_optgroup(&o, g);
2461 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2462 "%s.\n", inout, g->arg);
2466 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2467 ret = open_file(&o, g->arg);
2470 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2474 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2480 int avconv_parse_options(int argc, char **argv)
2482 OptionParseContext octx;
2486 memset(&octx, 0, sizeof(octx));
2488 /* split the commandline into an internal representation */
2489 ret = split_commandline(&octx, argc, argv, options, groups,
2490 FF_ARRAY_ELEMS(groups));
2492 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2496 /* apply global options */
2497 ret = parse_optgroup(NULL, &octx.global_opts);
2499 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2503 /* open input files */
2504 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2506 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2510 /* create the complex filtergraphs */
2511 ret = init_complex_filters();
2513 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2517 /* open output files */
2518 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2520 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2525 uninit_parse_context(&octx);
2527 av_strerror(ret, error, sizeof(error));
2528 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2533 #define OFFSET(x) offsetof(OptionsContext, x)
2534 const OptionDef options[] = {
2536 CMDUTILS_COMMON_OPTIONS
2537 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2538 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2539 "force format", "fmt" },
2540 { "y", OPT_BOOL, { &file_overwrite },
2541 "overwrite output files" },
2542 { "n", OPT_BOOL, { &file_skip },
2543 "never overwrite output files" },
2544 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2545 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2546 "codec name", "codec" },
2547 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2548 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2549 "codec name", "codec" },
2550 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2551 OPT_OUTPUT, { .off = OFFSET(presets) },
2552 "preset name", "preset" },
2553 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2554 OPT_OUTPUT, { .func_arg = opt_map },
2555 "set input stream mapping",
2556 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2557 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2558 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2559 "set metadata information of outfile from infile",
2560 "outfile[,metadata]:infile[,metadata]" },
2561 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2562 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2563 "set chapters mapping", "input_file_index" },
2564 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2565 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2566 "record or transcode \"duration\" seconds of audio/video",
2568 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2569 "set the limit file size in bytes", "limit_size" },
2570 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2571 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2572 "set the start time offset", "time_off" },
2573 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2574 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2575 "enable/disable accurate seeking with -ss" },
2576 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2577 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2578 "set the input ts offset", "time_off" },
2579 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2580 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2581 "set the input ts scale", "scale" },
2582 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2583 "add metadata", "string=string" },
2584 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2585 OPT_OUTPUT, { .func_arg = opt_data_frames },
2586 "set the number of data frames to record", "number" },
2587 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2588 "add timings for benchmarking" },
2589 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2590 "set max runtime in seconds", "limit" },
2591 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2592 "dump each input packet" },
2593 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2594 "when dumping packets, also dump the payload" },
2595 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2596 OPT_INPUT, { .off = OFFSET(rate_emu) },
2597 "read input at native frame rate", "" },
2598 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2599 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2600 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2601 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
2602 "video sync method", "" },
2603 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2604 "audio sync method", "" },
2605 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2606 "audio drift threshold", "threshold" },
2607 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2608 "copy timestamps" },
2609 { "copytb", OPT_BOOL | OPT_EXPERT, { ©_tb },
2610 "copy input stream time base when stream copying" },
2611 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2612 OPT_OUTPUT, { .off = OFFSET(shortest) },
2613 "finish encoding within shortest input" },
2614 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2615 "timestamp discontinuity delta threshold", "threshold" },
2616 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2617 "exit on error", "error" },
2618 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2619 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2620 "copy initial non-keyframes" },
2621 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2622 "set the number of frames to record", "number" },
2623 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2624 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2625 "force codec tag/fourcc", "fourcc/tag" },
2626 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2627 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2628 "use fixed quality scale (VBR)", "q" },
2629 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2630 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2631 "use fixed quality scale (VBR)", "q" },
2632 { "b", HAS_ARG | OPT_INT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(bitrates) },
2633 "set stream bitrate in bits/second", "bitrate" },
2634 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2635 "set stream filterchain", "filter_list" },
2636 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2637 "read stream filtergraph description from a file", "filename" },
2638 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2639 "create a complex filtergraph", "graph_description" },
2640 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2641 "read complex filtergraph description from a file", "filename" },
2642 { "stats", OPT_BOOL, { &print_stats },
2643 "print progress report during encoding", },
2644 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2645 OPT_OUTPUT, { .func_arg = opt_attach },
2646 "add an attachment to the output file", "filename" },
2647 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2648 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2649 "extract an attachment into a file", "filename" },
2650 { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2651 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2654 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2655 "set the number of video frames to record", "number" },
2656 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2657 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2658 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2659 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2660 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2661 "set frame size (WxH or abbreviation)", "size" },
2662 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2663 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2664 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2665 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2666 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2667 "set pixel format", "format" },
2668 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(video_disable) },
2670 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2671 "discard threshold", "n" },
2672 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2673 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2674 "rate control override for specific intervals", "override" },
2675 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2676 OPT_OUTPUT, { .func_arg = opt_video_codec },
2677 "force video codec ('copy' to copy stream)", "codec" },
2678 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2679 "select the pass number (1 or 2)", "n" },
2680 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2681 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2682 "select two pass log file name prefix", "prefix" },
2683 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = &opt_vstats },
2684 "dump video coding statistics to file" },
2685 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
2686 "dump video coding statistics to file", "file" },
2687 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2688 "video filters", "filter list" },
2689 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2690 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2691 "specify intra matrix coeffs", "matrix" },
2692 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2693 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2694 "specify inter matrix coeffs", "matrix" },
2695 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2696 OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2697 "top=1/bottom=0/auto=-1 field first", "" },
2698 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2699 "intra_dc_precision", "precision" },
2700 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2701 OPT_OUTPUT, { .func_arg = opt_video_tag },
2702 "force video tag/fourcc", "fourcc/tag" },
2703 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2704 "show QP histogram" },
2705 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2706 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2707 "force the selected framerate, disable the best supported framerate selection" },
2708 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2709 OPT_OUTPUT, { .func_arg = opt_streamid },
2710 "set the value of an outfile streamid", "streamIndex:value" },
2711 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2712 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2713 "force key frames at specified timestamps", "timestamps" },
2714 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2715 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2716 "use HW accelerated decoding", "hwaccel name" },
2717 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2718 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2719 "select a device for HW acceleration", "devicename" },
2720 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2721 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
2722 "select output format used with HW accelerated decoding", "format" },
2724 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
2725 "show available HW acceleration methods" },
2726 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
2727 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
2728 "automatically insert correct rotate filters" },
2729 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
2730 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2733 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2734 "set the number of audio frames to record", "number" },
2735 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2736 "set audio quality (codec-specific)", "quality", },
2737 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2738 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2739 "set audio sampling rate (in Hz)", "rate" },
2740 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2741 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2742 "set number of audio channels", "channels" },
2743 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(audio_disable) },
2745 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2746 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2747 "force audio codec ('copy' to copy stream)", "codec" },
2748 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2749 OPT_OUTPUT, { .func_arg = opt_audio_tag },
2750 "force audio tag/fourcc", "fourcc/tag" },
2751 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2752 "change audio volume (256=normal)" , "volume" },
2753 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2754 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2755 "set sample format", "format" },
2756 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2757 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2758 "set channel layout", "layout" },
2759 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2760 "audio filters", "filter list" },
2762 /* subtitle options */
2763 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2764 "disable subtitle" },
2765 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2766 "force subtitle codec ('copy' to copy stream)", "codec" },
2767 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2768 , "force subtitle tag/fourcc", "fourcc/tag" },
2771 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2774 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2775 "set the maximum demux-decode delay", "seconds" },
2776 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2777 "set the initial demux-decode delay", "seconds" },
2779 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2780 "A comma-separated list of bitstream filters", "bitstream_filters" },
2782 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
2783 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2785 /* data codec support */
2786 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2787 "force data codec ('copy' to copy stream)", "codec" },
2790 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2791 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
2794 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
2795 "initialise hardware device", "args" },
2796 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
2797 "set hardware device used when filtering", "device" },