diff options
| -rwxr-xr-x | configure | 3 | ||||
| -rw-r--r-- | libavcodec/Makefile | 1 | ||||
| -rw-r--r-- | libavcodec/allcodecs.c | 1 | ||||
| -rw-r--r-- | libavcodec/vaapi_encode_vp9.c | 313 | ||||
| -rw-r--r-- | libavcodec/version.h | 2 |
5 files changed, 319 insertions, 1 deletions
@@ -2797,6 +2797,8 @@ vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8" vp8_vaapi_encoder_select="vaapi_encode" vp9_cuvid_decoder_deps="cuda cuvid" vp9_mediacodec_decoder_deps="mediacodec" +vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9" +vp9_vaapi_encoder_select="vaapi_encode" wmv3_crystalhd_decoder_select="crystalhd" wmv3_vdpau_decoder_select="vc1_vdpau_decoder" @@ -5725,6 +5727,7 @@ check_type "va/va.h va/va_enc_hevc.h" "VAEncPictureParameterBufferHEVC" check_type "va/va.h va/va_enc_jpeg.h" "VAEncPictureParameterBufferJPEG" check_type "va/va.h va/va_enc_mpeg2.h" "VAEncPictureParameterBufferMPEG2" check_type "va/va.h va/va_enc_vp8.h" "VAEncPictureParameterBufferVP8" +check_type "va/va.h va/va_enc_vp9.h" "VAEncPictureParameterBufferVP9" check_type "vdpau/vdpau.h" "VdpPictureInfoHEVC" diff --git a/libavcodec/Makefile b/libavcodec/Makefile index b5cc748e19..f0cba8843d 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -627,6 +627,7 @@ OBJS-$(CONFIG_VP9_DECODER) += vp9.o vp9data.o vp9dsp.o vp9lpf.o vp9r vp9dsp_8bpp.o vp9dsp_10bpp.o vp9dsp_12bpp.o OBJS-$(CONFIG_VP9_CUVID_DECODER) += cuvid.o OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER) += mediacodecdec.o +OBJS-$(CONFIG_VP9_VAAPI_ENCODER) += vaapi_encode_vp9.o OBJS-$(CONFIG_VPLAYER_DECODER) += textdec.o ass.o OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o OBJS-$(CONFIG_WAVPACK_DECODER) += wavpack.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 27110e1cfd..54a9e8c42e 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -680,6 +680,7 @@ static void register_all(void) REGISTER_ENCODER(VP8_VAAPI, vp8_vaapi); REGISTER_DECODER(VP9_CUVID, vp9_cuvid); REGISTER_DECODER(VP9_MEDIACODEC, vp9_mediacodec); + REGISTER_ENCODER(VP9_VAAPI, vp9_vaapi); /* parsers */ REGISTER_PARSER(AAC, aac); diff --git a/libavcodec/vaapi_encode_vp9.c b/libavcodec/vaapi_encode_vp9.c new file mode 100644 index 0000000000..a987d1cd71 --- /dev/null +++ b/libavcodec/vaapi_encode_vp9.c @@ -0,0 +1,313 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <va/va.h> +#include <va/va_enc_vp9.h> + +#include "libavutil/avassert.h" +#include "libavutil/common.h" +#include "libavutil/internal.h" +#include "libavutil/opt.h" +#include "libavutil/pixfmt.h" + +#include "avcodec.h" +#include "internal.h" +#include "vaapi_encode.h" + +#define VP9_MAX_QUANT 255 + + +typedef struct VAAPIEncodeVP9Context { + int q_idx_idr; + int q_idx_p; + int q_idx_b; + + // Reference direction for B-like frames: + // 0 - most recent P/IDR frame is last. + // 1 - most recent P frame is golden. + int last_ref_dir; +} VAAPIEncodeVP9Context; + +typedef struct VAAPIEncodeVP9Options { + int loop_filter_level; + int loop_filter_sharpness; +} VAAPIEncodeVP9Options; + + +#define vseq_var(name) vseq->name, name +#define vseq_field(name) vseq->seq_fields.bits.name, name +#define vpic_var(name) vpic->name, name +#define vpic_field(name) vpic->pic_fields.bits.name, name + + +static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx) +{ + VAAPIEncodeContext *ctx = avctx->priv_data; + VAEncSequenceParameterBufferVP9 *vseq = ctx->codec_sequence_params; + VAEncPictureParameterBufferVP9 *vpic = ctx->codec_picture_params; + + vseq->max_frame_width = avctx->width; + vseq->max_frame_height = avctx->height; + + vseq->kf_auto = 0; + + if (!(ctx->va_rc_mode & VA_RC_CQP)) { + vseq->bits_per_second = avctx->bit_rate; + vseq->intra_period = avctx->gop_size; + } + + vpic->frame_width_src = avctx->width; + vpic->frame_height_src = avctx->height; + vpic->frame_width_dst = avctx->width; + vpic->frame_height_dst = avctx->height; + + return 0; +} + +static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx, + VAAPIEncodePicture *pic) +{ + VAAPIEncodeContext *ctx = avctx->priv_data; + VAEncPictureParameterBufferVP9 *vpic = pic->codec_picture_params; + VAAPIEncodeVP9Context *priv = ctx->priv_data; + VAAPIEncodeVP9Options *opt = ctx->codec_options; + int i; + + vpic->reconstructed_frame = pic->recon_surface; + vpic->coded_buf = pic->output_buffer; + + switch (pic->type) { + case PICTURE_TYPE_IDR: + av_assert0(pic->nb_refs == 0); + vpic->ref_flags.bits.force_kf = 1; + vpic->refresh_frame_flags = 0x01; + priv->last_ref_dir = 0; + break; + case PICTURE_TYPE_P: + av_assert0(pic->nb_refs == 1); + if (avctx->max_b_frames > 0) { + if (priv->last_ref_dir) { + vpic->ref_flags.bits.ref_frame_ctrl_l0 = 2; + vpic->ref_flags.bits.ref_gf_idx = 1; + vpic->ref_flags.bits.ref_gf_sign_bias = 1; + vpic->refresh_frame_flags = 0x01; + } else { + vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1; + vpic->ref_flags.bits.ref_last_idx = 0; + vpic->ref_flags.bits.ref_last_sign_bias = 1; + vpic->refresh_frame_flags = 0x02; + } + } else { + vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1; + vpic->ref_flags.bits.ref_last_idx = 0; + vpic->ref_flags.bits.ref_last_sign_bias = 1; + vpic->refresh_frame_flags = 0x01; + } + break; + case PICTURE_TYPE_B: + av_assert0(pic->nb_refs == 2); + if (priv->last_ref_dir) { + vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1; + vpic->ref_flags.bits.ref_frame_ctrl_l1 = 2; + vpic->ref_flags.bits.ref_last_idx = 0; + vpic->ref_flags.bits.ref_last_sign_bias = 1; + vpic->ref_flags.bits.ref_gf_idx = 1; + vpic->ref_flags.bits.ref_gf_sign_bias = 0; + } else { + vpic->ref_flags.bits.ref_frame_ctrl_l0 = 2; + vpic->ref_flags.bits.ref_frame_ctrl_l1 = 1; + vpic->ref_flags.bits.ref_last_idx = 0; + vpic->ref_flags.bits.ref_last_sign_bias = 0; + vpic->ref_flags.bits.ref_gf_idx = 1; + vpic->ref_flags.bits.ref_gf_sign_bias = 1; + } + vpic->refresh_frame_flags = 0x00; + break; + default: + av_assert0(0 && "invalid picture type"); + } + + for (i = 0; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++) + vpic->reference_frames[i] = VA_INVALID_SURFACE; + if (pic->type == PICTURE_TYPE_P) { + av_assert0(pic->refs[0]); + vpic->reference_frames[priv->last_ref_dir] = + pic->refs[0]->recon_surface; + } else if (pic->type == PICTURE_TYPE_B) { + av_assert0(pic->refs[0] && pic->refs[1]); + vpic->reference_frames[!priv->last_ref_dir] = + pic->refs[0]->recon_surface; + vpic->reference_frames[priv->last_ref_dir] = + pic->refs[1]->recon_surface; + } + + vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR); + vpic->pic_flags.bits.show_frame = pic->display_order <= pic->encode_order; + + if (pic->type == PICTURE_TYPE_IDR) + vpic->luma_ac_qindex = priv->q_idx_idr; + else if (pic->type == PICTURE_TYPE_P) + vpic->luma_ac_qindex = priv->q_idx_p; + else + vpic->luma_ac_qindex = priv->q_idx_b; + vpic->luma_dc_qindex_delta = 0; + vpic->chroma_ac_qindex_delta = 0; + vpic->chroma_dc_qindex_delta = 0; + + vpic->filter_level = opt->loop_filter_level; + vpic->sharpness_level = opt->loop_filter_sharpness; + + if (avctx->max_b_frames > 0 && pic->type == PICTURE_TYPE_P) + priv->last_ref_dir = !priv->last_ref_dir; + + return 0; +} + +static av_cold int vaapi_encode_vp9_configure(AVCodecContext *avctx) +{ + VAAPIEncodeContext *ctx = avctx->priv_data; + VAAPIEncodeVP9Context *priv = ctx->priv_data; + + priv->q_idx_p = av_clip(avctx->global_quality, 0, VP9_MAX_QUANT); + if (avctx->i_quant_factor > 0.0) + priv->q_idx_idr = av_clip((avctx->global_quality * + avctx->i_quant_factor + + avctx->i_quant_offset) + 0.5, + 0, VP9_MAX_QUANT); + else + priv->q_idx_idr = priv->q_idx_p; + if (avctx->b_quant_factor > 0.0) + priv->q_idx_b = av_clip((avctx->global_quality * + avctx->b_quant_factor + + avctx->b_quant_offset) + 0.5, + 0, VP9_MAX_QUANT); + else + priv->q_idx_b = priv->q_idx_p; + + return 0; +} + +static const VAAPIEncodeType vaapi_encode_type_vp9 = { + .configure = &vaapi_encode_vp9_configure, + + .priv_data_size = sizeof(VAAPIEncodeVP9Context), + + .sequence_params_size = sizeof(VAEncSequenceParameterBufferVP9), + .init_sequence_params = &vaapi_encode_vp9_init_sequence_params, + + .picture_params_size = sizeof(VAEncPictureParameterBufferVP9), + .init_picture_params = &vaapi_encode_vp9_init_picture_params, +}; + +static av_cold int vaapi_encode_vp9_init(AVCodecContext *avctx) +{ + VAAPIEncodeContext *ctx = avctx->priv_data; + + ctx->codec = &vaapi_encode_type_vp9; + + switch (avctx->profile) { + case FF_PROFILE_VP9_0: + case FF_PROFILE_UNKNOWN: + ctx->va_profile = VAProfileVP9Profile0; + ctx->va_rt_format = VA_RT_FORMAT_YUV420; + break; + case FF_PROFILE_VP9_1: + av_log(avctx, AV_LOG_ERROR, "VP9 profile 1 is not " + "supported.\n"); + return AVERROR_PATCHWELCOME; + case FF_PROFILE_VP9_2: + ctx->va_profile = VAProfileVP9Profile2; + ctx->va_rt_format = VA_RT_FORMAT_YUV420_10BPP; + break; + case FF_PROFILE_VP9_3: + av_log(avctx, AV_LOG_ERROR, "VP9 profile 3 is not " + "supported.\n"); + return AVERROR_PATCHWELCOME; + default: + av_log(avctx, AV_LOG_ERROR, "Unknown VP9 profile %d.\n", + avctx->profile); + return AVERROR(EINVAL); + } + ctx->va_entrypoint = VAEntrypointEncSlice; + + if (avctx->flags & AV_CODEC_FLAG_QSCALE) { + ctx->va_rc_mode = VA_RC_CQP; + } else if (avctx->bit_rate > 0) { + if (avctx->bit_rate == avctx->rc_max_rate) + ctx->va_rc_mode = VA_RC_CBR; + else + ctx->va_rc_mode = VA_RC_VBR; + } else { + ctx->va_rc_mode = VA_RC_CQP; + } + + // Packed headers are not currently supported. + ctx->va_packed_headers = 0; + + // Surfaces must be aligned to superblock boundaries. + ctx->surface_width = FFALIGN(avctx->width, 64); + ctx->surface_height = FFALIGN(avctx->height, 64); + + return ff_vaapi_encode_init(avctx); +} + +#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \ + offsetof(VAAPIEncodeVP9Options, x)) +#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) +static const AVOption vaapi_encode_vp9_options[] = { + { "loop_filter_level", "Loop filter level", + OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS }, + { "loop_filter_sharpness", "Loop filter sharpness", + OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS }, + { NULL }, +}; + +static const AVCodecDefault vaapi_encode_vp9_defaults[] = { + { "profile", "0" }, + { "b", "0" }, + { "bf", "0" }, + { "g", "250" }, + { "global_quality", "100" }, + { NULL }, +}; + +static const AVClass vaapi_encode_vp9_class = { + .class_name = "vp9_vaapi", + .item_name = av_default_item_name, + .option = vaapi_encode_vp9_options, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVCodec ff_vp9_vaapi_encoder = { + .name = "vp9_vaapi", + .long_name = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_VP9, + .priv_data_size = (sizeof(VAAPIEncodeContext) + + sizeof(VAAPIEncodeVP9Options)), + .init = &vaapi_encode_vp9_init, + .encode2 = &ff_vaapi_encode2, + .close = &ff_vaapi_encode_close, + .priv_class = &vaapi_encode_vp9_class, + .capabilities = AV_CODEC_CAP_DELAY, + .defaults = vaapi_encode_vp9_defaults, + .pix_fmts = (const enum AVPixelFormat[]) { + AV_PIX_FMT_VAAPI, + AV_PIX_FMT_NONE, + }, +}; diff --git a/libavcodec/version.h b/libavcodec/version.h index 8a67e0e6c5..1eaaf832ca 100644 --- a/libavcodec/version.h +++ b/libavcodec/version.h @@ -29,7 +29,7 @@ #define LIBAVCODEC_VERSION_MAJOR 57 #define LIBAVCODEC_VERSION_MINOR 99 -#define LIBAVCODEC_VERSION_MICRO 101 +#define LIBAVCODEC_VERSION_MICRO 102 #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ LIBAVCODEC_VERSION_MINOR, \ |