#endif
#if CONFIG_VDA
{ "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
+#endif
+#if CONFIG_LIBMFX
+ { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
+#endif
+#if CONFIG_VAAPI
+ { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
#endif
{ 0 },
};
+int hwaccel_lax_profile_check = 0;
+AVBufferRef *hw_device_ctx;
char *vstats_filename;
return 0;
}
+#if CONFIG_VAAPI
+static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
+{
+ int err;
+ err = vaapi_device_init(arg);
+ if (err < 0)
+ exit_program(1);
+ return 0;
+}
+#endif
+
/**
* Parse a metadata specifier passed as 'arg' parameter.
* @param arg metadata string to parse
MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
if (codec_name) {
- AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
- st->codec->codec_id = codec->id;
+ AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
+ st->codecpar->codec_id = codec->id;
return codec;
} else
- return avcodec_find_decoder(st->codec->codec_id);
+ return avcodec_find_decoder(st->codecpar->codec_id);
}
/* Add all the streams from the given input file to the global
for (i = 0; i < ic->nb_streams; i++) {
AVStream *st = ic->streams[i];
- AVCodecContext *dec = st->codec;
+ AVCodecParameters *par = st->codecpar;
InputStream *ist = av_mallocz(sizeof(*ist));
char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
+ char *hwaccel_output_format = NULL;
char *codec_tag = NULL;
char *next;
ist->file_index = nb_input_files;
ist->discard = 1;
st->discard = AVDISCARD_ALL;
+ ist->nb_samples = 0;
+ ist->min_pts = INT64_MAX;
+ ist->max_pts = INT64_MIN;
ist->ts_scale = 1.0;
MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
uint32_t tag = strtol(codec_tag, &next, 0);
if (*next)
tag = AV_RL32(codec_tag);
- st->codec->codec_tag = tag;
+ st->codecpar->codec_tag = tag;
}
ist->dec = choose_decoder(o, ic, st);
- ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
+ ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
ist->dec_ctx = avcodec_alloc_context3(ist->dec);
if (!ist->dec_ctx) {
exit_program(1);
}
- ret = avcodec_copy_context(ist->dec_ctx, dec);
+ ret = avcodec_parameters_to_context(ist->dec_ctx, par);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
exit_program(1);
}
- switch (dec->codec_type) {
+ switch (par->codec_type) {
case AVMEDIA_TYPE_VIDEO:
ist->resample_height = ist->dec_ctx->height;
ist->resample_width = ist->dec_ctx->width;
if (!ist->hwaccel_device)
exit_program(1);
}
+
+ MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
+ hwaccel_output_format, ic, st);
+ if (hwaccel_output_format) {
+ ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
+ if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
+ av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
+ "format: %s", hwaccel_output_format);
+ }
+ } else {
+ ist->hwaccel_output_format = AV_PIX_FMT_NONE;
+ }
+
ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
break;
AVIOContext *out = NULL;
AVDictionaryEntry *e;
- if (!st->codec->extradata_size) {
+ if (!st->codecpar->extradata_size) {
av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
nb_input_files - 1, st->index);
return;
exit_program(1);
}
- avio_write(out, st->codec->extradata, st->codec->extradata_size);
+ avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
avio_flush(out);
avio_close(out);
}
f->nb_streams = ic->nb_streams;
f->rate_emu = o->rate_emu;
f->accurate_seek = o->accurate_seek;
+ f->loop = o->loop;
+ f->duration = 0;
+ f->time_base = (AVRational){ 1, 1 };
/* check if all codec options have been used */
unused_opts = strip_specifiers(o->g->codec_opts);
MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
if (!codec_name) {
- ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
- NULL, ost->st->codec->codec_type);
- ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
+ ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
+ NULL, ost->st->codecpar->codec_type);
+ ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
} else if (!strcmp(codec_name, "copy"))
ost->stream_copy = 1;
else {
- ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
- ost->st->codec->codec_id = ost->enc->id;
+ ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
+ ost->st->codecpar->codec_id = ost->enc->id;
}
}
AVStream *st = avformat_new_stream(oc, NULL);
int idx = oc->nb_streams - 1, ret = 0;
char *bsf = NULL, *next, *codec_tag = NULL;
- AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
double qscale = -1;
if (!st) {
ost->file_index = nb_output_files - 1;
ost->index = idx;
ost->st = st;
- st->codec->codec_type = type;
+ st->codecpar->codec_type = type;
choose_encoder(o, oc, ost);
ost->enc_ctx = avcodec_alloc_context3(ost->enc);
MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
while (bsf) {
+ const AVBitStreamFilter *filter;
+
if (next = strchr(bsf, ','))
*next++ = 0;
- if (!(bsfc = av_bitstream_filter_init(bsf))) {
+
+ filter = av_bsf_get_by_name(bsf);
+ if (!bsf) {
av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
exit_program(1);
}
- if (bsfc_prev)
- bsfc_prev->next = bsfc;
- else
- ost->bitstream_filters = bsfc;
- bsfc_prev = bsfc;
- bsf = next;
+ ost->bitstream_filters = av_realloc_array(ost->bitstream_filters,
+ ost->nb_bitstream_filters + 1,
+ sizeof(*ost->bitstream_filters));
+ if (!ost->bitstream_filters)
+ exit_program(1);
+
+ ost->bitstream_filters[ost->nb_bitstream_filters++] = filter;
+
+ bsf = next;
}
MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
else if (filter)
return av_strdup(filter);
- return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
+ return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
"null" : "anull");
}
int area = 0, idx = -1;
for (i = 0; i < nb_input_streams; i++) {
ist = input_streams[i];
- if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
- ist->st->codec->width * ist->st->codec->height > area) {
- area = ist->st->codec->width * ist->st->codec->height;
+ if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
+ ist->st->codecpar->width * ist->st->codecpar->height > area) {
+ area = ist->st->codecpar->width * ist->st->codecpar->height;
idx = i;
}
}
int channels = 0, idx = -1;
for (i = 0; i < nb_input_streams; i++) {
ist = input_streams[i];
- if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
- ist->st->codec->channels > channels) {
- channels = ist->st->codec->channels;
+ if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
+ ist->st->codecpar->channels > channels) {
+ channels = ist->st->codecpar->channels;
idx = i;
}
}
/* subtitles: pick first */
if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
for (i = 0; i < nb_input_streams; i++)
- if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+ if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
NEW_STREAM(subtitle, i);
break;
}
init_output_filter(ofilter, o, oc);
} else {
ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
- switch (ist->st->codec->codec_type) {
+ switch (ist->st->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
ost->stream_copy = 0;
ost->source_index = -1;
ost->attachment_filename = o->attachments[i];
- ost->st->codec->extradata = attachment;
- ost->st->codec->extradata_size = len;
+ ost->st->codecpar->extradata = attachment;
+ ost->st->codecpar->extradata_size = len;
p = strrchr(o->attachments[i], '/');
av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
int i, j, fr;
for (j = 0; j < nb_input_files; j++) {
for (i = 0; i < input_files[j]->nb_streams; i++) {
- AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
- if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
- !c->time_base.num)
+ AVStream *st = input_files[j]->ctx->streams[i];
+ if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
continue;
- fr = c->time_base.den * 1000 / c->time_base.num;
+ fr = st->time_base.den * 1000 / st->time_base.num;
if (fr == 25000) {
norm = PAL;
break;
return 0;
}
-/* Search a class from a codec, format, or filter, named 'opt', in order
- * to extract its private options. If the class type is specified, only
- * the associated options are printed, otherwise all the ones matching
- * the input name are shown. */
-static int show_help_specific(const char *opt)
-{
- AVCodec *codec = NULL;
- AVFilter *filter = NULL;
- AVInputFormat *iformat = NULL;
- AVOutputFormat *oformat = NULL;
- int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM |
- AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM;
-
- char *kind = av_get_token(&opt, ":");
- if (!kind)
- return 0;
- if (*opt)
- opt = &opt[1]; // skip ':'
-
- show_usage();
-
- if (!strcmp(kind, "decoder") &&
- (codec = avcodec_find_decoder_by_name(opt)) && codec->priv_class)
- show_help_children(codec->priv_class, flags);
- else if (!strcmp(kind, "encoder") &&
- (codec = avcodec_find_encoder_by_name(opt)) && codec->priv_class)
- show_help_children(codec->priv_class, flags);
- else if (!strcmp(kind, "demuxer") &&
- (iformat = av_find_input_format(opt)) && iformat->priv_class)
- show_help_children(iformat->priv_class, flags);
- else if (!strcmp(kind, "muxer") &&
- (oformat = av_guess_format(opt, NULL, NULL)) && oformat->priv_class)
- show_help_children(oformat->priv_class, flags);
- else if (!strcmp(kind, "filter") &&
- (filter = avfilter_get_by_name(opt)) && filter->priv_class)
- show_help_children(filter->priv_class, flags);
- else if (!opt)
- av_log(NULL, AV_LOG_ERROR,
- "Unknown class '%s', only 'decoder', 'encoder', 'demuxer', "
- "'muxer', or 'filter' are valid specifiers.\n", kind);
- else {
- if ((codec = avcodec_find_decoder_by_name(kind)) && codec->priv_class)
- show_help_children(codec->priv_class, flags);
- if ((codec = avcodec_find_encoder_by_name(kind)) && codec->priv_class)
- show_help_children(codec->priv_class, flags);
- if ((iformat = av_find_input_format(kind)) && iformat->priv_class)
- show_help_children(iformat->priv_class, flags);
- if ((oformat = av_guess_format(kind, NULL, NULL)) && oformat->priv_class)
- show_help_children(oformat->priv_class, flags);
- if ((filter = avfilter_get_by_name(kind)) && filter->priv_class)
- show_help_children(filter->priv_class, flags);
- }
- av_freep(&kind);
-
- return codec || iformat || oformat || filter;
-}
-
void show_help_default(const char *opt, const char *arg)
{
/* per-file options have at least one of those set */
show_advanced = 1;
else if (!strcmp(opt, "full"))
show_advanced = show_avoptions = 1;
- else if (show_help_specific(opt))
- return;
else
av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
}
" -h -- print basic options\n"
" -h long -- print more options\n"
" -h full -- print all options (including all format and codec specific options, very long)\n"
- " -h [type:]name -- print private options from a codec, format or filter named 'name' (set 'type' to print options from a single class)\n"
+ " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
" See man %s for detailed description of the options.\n"
"\n", program_name);
{ "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
"extract an attachment into a file", "filename" },
+ { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
+ OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
/* video options */
{ "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
{ "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
"select a device for HW acceleration", "devicename" },
+ { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
+ OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
+ "select output format used with HW accelerated decoding", "format" },
+
{ "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
"show available HW acceleration methods" },
{ "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
"automatically insert correct rotate filters" },
+ { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
+ "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
/* audio options */
{ "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
{ "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
"force data codec ('copy' to copy stream)", "codec" },
+#if CONFIG_VAAPI
+ { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
+ "set VAAPI hardware device (DRM path or X11 display name)", "device" },
+#endif
+
{ NULL, },
};
projects / ffmpeg / blobdiff