Lynne:
> This commit adds a Vulkan AV1 encoder, using the native acceleration API.
> ---
> configure | 1 +
> libavcodec/Makefile | 2 +
> libavcodec/allcodecs.c | 1 +
> libavcodec/vulkan_encode_av1.c | 1385 ++++++++++++++++++++++++++++++++
> libavcodec/vulkan_video.c | 103 +++
> libavcodec/vulkan_video.h | 7 +
> libavutil/hwcontext_vulkan.c | 2 +
> libavutil/vulkan_functions.h | 1 +
> libavutil/vulkan_loader.h | 1 +
> 9 files changed, 1503 insertions(+)
> create mode 100644 libavcodec/vulkan_encode_av1.c
>
> diff --git a/configure b/configure
> index bd4f872376..d5293ed652 100755
> --- a/configure
> +++ b/configure
> @@ -3380,6 +3380,7 @@ av1_qsv_encoder_deps="libvpl"
> av1_qsv_encoder_select="qsvenc"
> av1_vaapi_encoder_deps="VAEncPictureParameterBufferAV1"
> av1_vaapi_encoder_select="cbs_av1 vaapi_encode"
> +av1_vulkan_encoder_select="cbs_av1 vulkan_encode"
> h263_v4l2m2m_decoder_deps="v4l2_m2m h263_v4l2_m2m"
> h263_v4l2m2m_encoder_deps="v4l2_m2m h263_v4l2_m2m"
> h264_amf_encoder_deps="amf"
> diff --git a/libavcodec/Makefile b/libavcodec/Makefile
> index 7bd1dbec9a..b15b99d6c2 100644
> --- a/libavcodec/Makefile
> +++ b/libavcodec/Makefile
> @@ -270,6 +270,8 @@ OBJS-$(CONFIG_AV1_MEDIACODEC_ENCODER) += mediacodecenc.o
> OBJS-$(CONFIG_AV1_NVENC_ENCODER) += nvenc_av1.o nvenc.o
> OBJS-$(CONFIG_AV1_QSV_ENCODER) += qsvenc_av1.o
> OBJS-$(CONFIG_AV1_VAAPI_ENCODER) += vaapi_encode_av1.o av1_levels.o
> +OBJS-$(CONFIG_AV1_VULKAN_ENCODER) += vulkan_encode.o
> vulkan_encode_av1.o \
> + hw_base_encode.o av1_levels.o
> OBJS-$(CONFIG_AVRN_DECODER) += avrndec.o
> OBJS-$(CONFIG_AVRP_DECODER) += r210dec.o
> OBJS-$(CONFIG_AVRP_ENCODER) += r210enc.o
> diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
> index f10519617e..733f1aa009 100644
> --- a/libavcodec/allcodecs.c
> +++ b/libavcodec/allcodecs.c
> @@ -849,6 +849,7 @@ extern const FFCodec ff_av1_amf_encoder;
> extern const FFCodec ff_av1_amf_decoder;
> extern const FFCodec ff_av1_mf_encoder;
> extern const FFCodec ff_av1_vaapi_encoder;
> +extern const FFCodec ff_av1_vulkan_encoder;
> extern const FFCodec ff_libopenh264_encoder;
> extern const FFCodec ff_libopenh264_decoder;
> extern const FFCodec ff_h264_amf_encoder;
> diff --git a/libavcodec/vulkan_encode_av1.c b/libavcodec/vulkan_encode_av1.c
> new file mode 100644
> index 0000000000..596586e7e2
> --- /dev/null
> +++ b/libavcodec/vulkan_encode_av1.c
> @@ -0,0 +1,1385 @@
> +/*
> + * 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 "libavutil/opt.h"
> +#include "libavutil/mem.h"
> +
> +#include "cbs.h"
> +#include "cbs_av1.h"
> +#include "av1_levels.h"
> +#include "libavutil/mastering_display_metadata.h"
> +
> +#include "codec_internal.h"
> +#include "vulkan_encode.h"
> +
> +#include "libavutil/avassert.h"
> +
> +const FFVulkanEncodeDescriptor ff_vk_enc_av1_desc = {
> + .codec_id = AV_CODEC_ID_AV1,
> + .encode_extension = FF_VK_EXT_VIDEO_ENCODE_AV1,
> + .encode_op = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR,
> + .ext_props = {
> + .extensionName = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME,
> + .specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION,
> + },
> +};
> +
> +enum UnitElems {
> + UNIT_MASTERING_DISPLAY = 1 << 0,
> + UNIT_CONTENT_LIGHT_LEVEL = 1 << 1,
> +};
> +
> +typedef struct VulkanEncodeAV1Picture {
> + int slot;
> + int64_t last_idr_frame;
> +
> + enum UnitElems units_needed;
> +
> + StdVideoAV1TileInfo tile_info;
> + StdVideoAV1Quantization quantization;
> + StdVideoAV1Segmentation segmentation;
> + StdVideoAV1LoopFilter loop_filter;
> + StdVideoAV1CDEF cdef;
> + StdVideoAV1LoopRestoration loop_restoration;
> + StdVideoAV1GlobalMotion global_motion;
> +
> + StdVideoEncodeAV1PictureInfo av1pic_info;
> + VkVideoEncodeAV1PictureInfoKHR vkav1pic_info;
> +
> + StdVideoEncodeAV1ExtensionHeader ext_header;
> + StdVideoEncodeAV1ReferenceInfo av1dpb_info;
> + VkVideoEncodeAV1DpbSlotInfoKHR vkav1dpb_info;
> +
> + VkVideoEncodeAV1RateControlInfoKHR vkrc_info;
> + VkVideoEncodeAV1RateControlLayerInfoKHR vkrc_layer_info;
> + VkVideoEncodeAV1GopRemainingFrameInfoKHR vkrc_remaining;
> +} VulkanEncodeAV1Picture;
> +
> +typedef struct VulkanEncodeAV1Context {
> + FFVulkanEncodeContext common;
> +
> + CodedBitstreamContext *cbs;
> + CodedBitstreamFragment current_access_unit;
> +
> + enum UnitElems unit_elems;
> + AV1RawOBU seq_hdr_obu;
> + AV1RawOBU meta_cll_obu;
> + AV1RawOBU meta_mastering_obu;
> +
> + VkVideoEncodeAV1ProfileInfoKHR profile;
> +
> + VkVideoEncodeAV1CapabilitiesKHR caps;
> + VkVideoEncodeAV1QualityLevelPropertiesKHR quality_props;
> +
> + uint64_t hrd_buffer_size;
> + uint64_t initial_buffer_fullness;
> +
> + int uniform_tile;
> + int tile_cols;
> + int tile_rows;
> +
> + int seq_tier;
> + int seq_level_idx;
> +
> + int q_idx_idr;
> + int q_idx_p;
> + int q_idx_b;
> +
> + uint8_t *padding_payload;
> +} VulkanEncodeAV1Context;
> +
> +static int init_pic_rc(AVCodecContext *avctx, FFHWBaseEncodePicture *pic,
> + VkVideoEncodeRateControlInfoKHR *rc_info,
> + VkVideoEncodeRateControlLayerInfoKHR *rc_layer)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + VulkanEncodeAV1Picture *ap = pic->codec_priv;
> +
> + /* This can be easy to calculate */
> + ap->vkrc_remaining = (VkVideoEncodeAV1GopRemainingFrameInfoKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR,
> + .useGopRemainingFrames = 0,
> + .gopRemainingIntra = 0,
> + .gopRemainingPredictive = 0,
> + .gopRemainingBipredictive = 0,
> + };
> +
> + ap->vkrc_info = (VkVideoEncodeAV1RateControlInfoKHR) {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR,
> + .flags =
> VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR |
> + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR,
> + .gopFrameCount = ctx->base.gop_size,
> + .keyFramePeriod = ctx->base.gop_size,
> + .consecutiveBipredictiveFrameCount = FFMAX(ctx->base.b_per_p - 1, 0),
> + .temporalLayerCount = 0,
> + };
> + rc_info->pNext = &ap->vkrc_info;
> +
> + if (rc_info->rateControlMode >
> VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) {
> + rc_info->virtualBufferSizeInMs = (enc->hrd_buffer_size * 1000LL) /
> avctx->bit_rate;
> + rc_info->initialVirtualBufferSizeInMs =
> (enc->initial_buffer_fullness * 1000LL) / avctx->bit_rate;
> +
> + ap->vkrc_layer_info = (VkVideoEncodeAV1RateControlLayerInfoKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR,
> +
> + .useMinQIndex = avctx->qmin > 0,
> + .minQIndex.intraQIndex = avctx->qmin > 0 ? avctx->qmin : 0,
> + .minQIndex.predictiveQIndex = avctx->qmin > 0 ? avctx->qmin : 0,
> + .minQIndex.bipredictiveQIndex = avctx->qmin > 0 ? avctx->qmin :
> 0,
> +
> + .useMaxQIndex = avctx->qmax > 0,
> + .maxQIndex.intraQIndex = avctx->qmax > 0 ? avctx->qmax : 0,
> + .maxQIndex.predictiveQIndex = avctx->qmax > 0 ? avctx->qmax : 0,
> + .maxQIndex.bipredictiveQIndex = avctx->qmax > 0 ? avctx->qmax :
> 0,
> +
> + .useMaxFrameSize = 0,
> + };
> + rc_layer->pNext = &ap->vkrc_layer_info;
> + ap->vkrc_info.temporalLayerCount = 1;
> + }
> +
> + return 0;
> +}
> +
> +static int init_pic_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic,
> + VkVideoEncodeInfoKHR *encode_info)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFHWBaseEncodeContext *base_ctx = &ctx->base;
> +
> + FFVulkanEncodePicture *vp = pic->priv;
> + VulkanEncodeAV1Picture *ap = pic->codec_priv;
> + FFHWBaseEncodePicture *ref;
> + VulkanEncodeAV1Picture *ap_ref;
> + VkVideoReferenceSlotInfoKHR *ref_slot;
> +
> + AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
> + AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
> +
> + StdVideoAV1Segmentation *segmentation = &ap->segmentation;
> + StdVideoAV1LoopFilter *loop_filter = &ap->loop_filter;
> + StdVideoAV1Quantization *quantization = &ap->quantization;
> + StdVideoAV1CDEF *cdef = &ap->cdef;
> + StdVideoAV1LoopRestoration *loop_restoration = &ap->loop_restoration;
> + StdVideoAV1GlobalMotion *global_motion = &ap->global_motion;
> + StdVideoAV1TileInfo *tile_info = &ap->tile_info;
> + static const int8_t
> default_loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME] =
> + { 1, 0, 0, 0, -1, 0, -1, -1 };
> +
> + VkVideoEncodeAV1PredictionModeKHR pred_mode;
> + VkVideoEncodeAV1RateControlGroupKHR rc_group;
> + int lr_unit_shift = 0;
> + int lr_uv_shift = 0;
> +
> + ap->ext_header = (StdVideoEncodeAV1ExtensionHeader) {
> + .temporal_id = 0,
> + .spatial_id = 0,
> + };
> +
> + *tile_info = (StdVideoAV1TileInfo) {
> + .flags = (StdVideoAV1TileInfoFlags) {
> + .uniform_tile_spacing_flag = enc->uniform_tile,
> + },
> + .TileCols = enc->tile_cols,
> + .TileRows = enc->tile_rows,
> + .context_update_tile_id = 0,
> + .tile_size_bytes_minus_1 = 0,
> + };
> +
> + for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++) {
> + global_motion->GmType[i] = 0;
> + for (int j = 0; j < STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS; j++) {
> + global_motion->gm_params[i][j] = 0;
> + }
> + }
> +
> + *loop_restoration = (StdVideoAV1LoopRestoration) {
> + .FrameRestorationType[0] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
> + .FrameRestorationType[1] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
> + .FrameRestorationType[2] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
> + .LoopRestorationSize[0] = 1 + lr_unit_shift,
> + .LoopRestorationSize[1] = 1 + lr_unit_shift - lr_uv_shift,
> + .LoopRestorationSize[2] = 1 + lr_unit_shift - lr_uv_shift,
> + };
> +
> + *cdef = (StdVideoAV1CDEF) {
> + .cdef_damping_minus_3 = 0,
> + .cdef_bits = 0,
> + };
> +
> + for (int i = 0; i < STD_VIDEO_AV1_MAX_SEGMENTS; i++) {
> + segmentation->FeatureEnabled[i] = 0x0;
> + for (int j = 0; j < STD_VIDEO_AV1_SEG_LVL_MAX; j++) {
> + segmentation->FeatureEnabled[i] |= 0x0;
> + segmentation->FeatureData[i][j] = 0;
> + }
> + }
> +
> + *loop_filter = (StdVideoAV1LoopFilter) {
> + .flags = (StdVideoAV1LoopFilterFlags) {
> + .loop_filter_delta_enabled = 0,
> + .loop_filter_delta_update = 0,
> + },
> + .loop_filter_level = { 0 },
> + .loop_filter_sharpness = 0,
> + .update_ref_delta = 0,
> + .loop_filter_ref_deltas = { 0 },
> + .update_mode_delta = 0,
> + .loop_filter_mode_deltas = { 0 },
> + };
> + loop_filter->update_mode_delta = 1;
> + memcpy(loop_filter->loop_filter_ref_deltas,
> default_loop_filter_ref_deltas,
> + STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME * sizeof(int8_t));
> +
> + *quantization = (StdVideoAV1Quantization) {
> + .flags = (StdVideoAV1QuantizationFlags) {
> + .using_qmatrix = 0,
> + .diff_uv_delta = 0,
> + /* Reserved */
> + },
> + .base_q_idx = 0, /* Set later */
> + .DeltaQYDc = 0,
> + .DeltaQUDc = 0,
> + .DeltaQUAc = 0,
> + .DeltaQVDc = 0,
> + .DeltaQVAc = 0,
> + .qm_y = 0,
> + .qm_u = 0,
> + .qm_v = 0,
> + };
> +
> + ref_slot = (VkVideoReferenceSlotInfoKHR
> *)encode_info->pSetupReferenceSlot;
> + ap->av1pic_info = (StdVideoEncodeAV1PictureInfo) {
> + .flags = (StdVideoEncodeAV1PictureInfoFlags) {
> + .error_resilient_mode = (pic->type == FF_HW_PICTURE_TYPE_I ||
> + pic->type == FF_HW_PICTURE_TYPE_IDR) &&
> + (pic->display_order <=
> pic->encode_order),
> + .disable_cdf_update = 0,
> + .use_superres = 0,
> + .render_and_frame_size_different = 0,
> + .allow_screen_content_tools = 0,
> + .is_filter_switchable = 0,
> + .force_integer_mv = 0,
> + .frame_size_override_flag = 0,
> + .buffer_removal_time_present_flag = 0,
> + .allow_intrabc = 0,
> + .frame_refs_short_signaling = 0,
> + .allow_high_precision_mv = 0,
> + .is_motion_mode_switchable = 0,
> + .use_ref_frame_mvs = 0,
> + .disable_frame_end_update_cdf = 0,
> + .allow_warped_motion = 0,
> + .reduced_tx_set = 0,
> + .skip_mode_present = 0,
> + .delta_q_present = 0,
> + .delta_lf_present = 0,
> + .delta_lf_multi = 0,
> + .segmentation_enabled = 0,
> + .segmentation_update_map = 0,
> + .segmentation_temporal_update = 0,
> + .segmentation_update_data = 0,
> + .UsesLr = 0,
> + .usesChromaLr = 0,
> + .show_frame = pic->display_order <= pic->encode_order,
> + .showable_frame = 0,
> + /* Reserved */
> + },
> + .frame_type = 0, // set later
> + .frame_presentation_time = 0,
> + .current_frame_id = ref_slot->slotIndex,
> + .order_hint = seq->enable_order_hint,
> + .primary_ref_frame = 0, // set later
> + .refresh_frame_flags = 0x0, // set later
> + .coded_denom = 0,
> + .render_width_minus_1 = base_ctx->surface_width - 1,
> + .render_height_minus_1 = base_ctx->surface_height - 1,
> + .interpolation_filter = 0,
> + .TxMode = STD_VIDEO_AV1_TX_MODE_SELECT,
> + .delta_q_res = 0,
> + .delta_lf_res = 0,
> + .ref_order_hint = { 0 }, // set later
> + .ref_frame_idx = { 0 }, // set later
> + /* Reserved */
> + .delta_frame_id_minus_1 = { 0 },
> +
> +// .pTileInfo = tile_info, TODO FIX
> + .pQuantization = quantization,
> + .pSegmentation = segmentation,
> + .pLoopFilter = loop_filter,
> + .pCDEF = cdef,
> + .pLoopRestoration = loop_restoration,
> + .pGlobalMotion = global_motion,
> + .pExtensionHeader = &ap->ext_header,
> + .pBufferRemovalTimes = NULL,
> + };
> +
> + switch (pic->type) {
> + case FF_HW_PICTURE_TYPE_I:
> + case FF_HW_PICTURE_TYPE_IDR:
> + av_assert0(pic->nb_refs[0] == 0 || pic->nb_refs[1]);
> + ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_KEY;
> + ap->av1pic_info.refresh_frame_flags = 0xFF;
> + quantization->base_q_idx = enc->q_idx_idr;
> + ap->slot = 0;
> + ap->last_idr_frame = pic->display_order;
> + pred_mode = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR;
> + rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR;
> + break;
> + case FF_HW_PICTURE_TYPE_P:
> + ref = pic->refs[0][pic->nb_refs[0] - 1];
> + ap_ref = ref->codec_priv;
> +
> + ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_INTER;
> + quantization->base_q_idx = enc->q_idx_p;
> +
> + ap->last_idr_frame = ap_ref->last_idr_frame;
> + ap->slot = !ap_ref->slot;
> +
> + ap->av1pic_info.refresh_frame_flags = 1 << ap->slot;
> +
> + /** set the nearest frame in L0 as all reference frame. */
> + for (int i = 0; i < AV1_REFS_PER_FRAME; i++)
> + ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
> +
> + ap->av1pic_info.primary_ref_frame = ap_ref->slot;
> + ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order -
> ap_ref->last_idr_frame;
> + rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR;
> + if (enc->caps.maxUnidirectionalCompoundReferenceCount)
> + pred_mode =
> VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR;
> + else
> + pred_mode =
> VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR;
> +
> +// vpic->ref_frame_ctrl_l0.fields.search_idx0 = AV1_REF_FRAME_LAST;
> +
> + /** set the 2nd nearest frame in L0 as Golden frame. */
> + if (pic->nb_refs[0] > 1) {
> + ref = pic->refs[0][pic->nb_refs[0] - 2];
> + ap_ref = ref->codec_priv;
> + ap->av1pic_info.ref_frame_idx[3] = ap_ref->slot;
> + ap->av1pic_info.ref_order_hint[ap_ref->slot] =
> ref->display_order - ap_ref->last_idr_frame;
> +// vpic->ref_frame_ctrl_l0.fields.search_idx1 =
> AV1_REF_FRAME_GOLDEN;
> + }
> + break;
> + case FF_HW_PICTURE_TYPE_B:
> + ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_INTER;
> + quantization->base_q_idx = enc->q_idx_b;
> + ap->av1pic_info.refresh_frame_flags = 0x0;
> +
> + rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR;
> + pred_mode =
> VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR;
> +
> +// fh->reference_select = 1;
> + /** B frame will not be referenced, disable its recon frame. */
> +// vpic->picture_flags.bits.disable_frame_recon = 1;
> +
> + /** Use LAST_FRAME and BWDREF_FRAME for reference. */
> +// vpic->ref_frame_ctrl_l0.fields.search_idx0 = AV1_REF_FRAME_LAST;
> +// vpic->ref_frame_ctrl_l1.fields.search_idx0 = AV1_REF_FRAME_BWDREF;
> +
> + ref = pic->refs[0][pic->nb_refs[0] - 1];
> + ap_ref = ref->codec_priv;
> + ap->last_idr_frame = ap_ref->last_idr_frame;
> + ap->av1pic_info.primary_ref_frame = ap_ref->slot;
> + ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order -
> ap_ref->last_idr_frame;
> + for (int i = 0; i < AV1_REF_FRAME_GOLDEN; i++)
> + ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
> +
> + ref = pic->refs[1][pic->nb_refs[1] - 1];
> + ap_ref = ref->codec_priv;
> + ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order -
> ap_ref->last_idr_frame;
> + for (int i = AV1_REF_FRAME_GOLDEN; i < AV1_REFS_PER_FRAME; i++)
> + ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
> + break;
> + }
> +
> + ap->av1pic_info.flags.showable_frame = ap->av1pic_info.frame_type !=
> STD_VIDEO_AV1_FRAME_TYPE_KEY;
> +
> + ap->vkav1pic_info = (VkVideoEncodeAV1PictureInfoKHR) {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR,
> + .pNext = NULL,
> + .predictionMode = pred_mode,
> + .rateControlGroup = rc_group,
> + .constantQIndex = quantization->base_q_idx,
> + .pStdPictureInfo = &ap->av1pic_info,
> + .referenceNameSlotIndices = { 0 },
> + .primaryReferenceCdfOnly = 0,
> + .generateObuExtensionHeader = 0,
> + };
> + encode_info->pNext = &ap->vkav1pic_info;
> +
> + /* TODO: not sure */
> + for (int i = 0; i < STD_VIDEO_AV1_REFS_PER_FRAME; i++) {
> + if (!enc->common.slots[i]) {
> + ap->vkav1pic_info.referenceNameSlotIndices[i] = -1;
> + } else {
> + ref = enc->common.slots[i];
> + ap_ref = ref->codec_priv;
> + ap->vkav1pic_info.referenceNameSlotIndices[i] =
> ap_ref->av1pic_info.current_frame_id;
> + }
> + }
> +
> + ref_slot = (VkVideoReferenceSlotInfoKHR
> *)encode_info->pSetupReferenceSlot;
> + ref_slot->pNext = &ap->vkav1dpb_info;
> +
> + ap->av1dpb_info = (StdVideoEncodeAV1ReferenceInfo) {
> + .flags = (StdVideoEncodeAV1ReferenceInfoFlags) {
> + .disable_frame_end_update_cdf = 0,
> + .segmentation_enabled = 0,
> + /* Reserved */
> + },
> + .RefFrameId = ref_slot->slotIndex,
> + .frame_type = ap->av1pic_info.frame_type,
> + .OrderHint = pic->display_order - ap->last_idr_frame,
> + /* Reserved */
> + .pExtensionHeader = &ap->ext_header,
> + };
> +
> + ap->vkav1dpb_info = (VkVideoEncodeAV1DpbSlotInfoKHR) {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR,
> + .pStdReferenceInfo = &ap->av1dpb_info,
> + };
> +
> + ap->units_needed = 0;
> + if (pic->type == FF_HW_PICTURE_TYPE_IDR) {
> + AVFrameSideData *sd = NULL;
> + if (enc->unit_elems & UNIT_MASTERING_DISPLAY)
> + sd = av_frame_get_side_data(pic->input_image,
> +
> AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
> + if (sd) {
> + AVMasteringDisplayMetadata *mdm =
> + (AVMasteringDisplayMetadata *)sd->data;
> + if (mdm->has_primaries && mdm->has_luminance) {
> + AV1RawOBU *obu = &enc->meta_mastering_obu;
> + AV1RawMetadata *md = &obu->obu.metadata;
> + AV1RawMetadataHDRMDCV *mdcv = &md->metadata.hdr_mdcv;
> + const int chroma_den = 1 << 16;
> + const int max_luma_den = 1 << 8;
> + const int min_luma_den = 1 << 14;
> +
> + memset(obu, 0, sizeof(*obu));
> + obu->header.obu_type = AV1_OBU_METADATA;
> + md->metadata_type = AV1_METADATA_TYPE_HDR_MDCV;
> +
> + for (int i = 0; i < 3; i++) {
> + mdcv->primary_chromaticity_x[i] =
> + av_rescale(mdm->display_primaries[i][0].num,
> chroma_den,
> + mdm->display_primaries[i][0].den);
> + mdcv->primary_chromaticity_y[i] =
> + av_rescale(mdm->display_primaries[i][1].num,
> chroma_den,
> + mdm->display_primaries[i][1].den);
> + }
> +
> + mdcv->white_point_chromaticity_x =
> + av_rescale(mdm->white_point[0].num, chroma_den,
> + mdm->white_point[0].den);
> + mdcv->white_point_chromaticity_y =
> + av_rescale(mdm->white_point[1].num, chroma_den,
> + mdm->white_point[1].den);
> +
> + mdcv->luminance_max =
> + av_rescale(mdm->max_luminance.num, max_luma_den,
> + mdm->max_luminance.den);
> + mdcv->luminance_min =
> + av_rescale(mdm->min_luminance.num, min_luma_den,
> + mdm->min_luminance.den);
> + ap->units_needed |= UNIT_MASTERING_DISPLAY;
> + }
> + }
> +
> + if (enc->unit_elems & UNIT_CONTENT_LIGHT_LEVEL)
> + sd = av_frame_get_side_data(pic->input_image,
> + AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
> + if (sd) {
> + AVContentLightMetadata *cllm = (AVContentLightMetadata
> *)sd->data;
> + AV1RawOBU *obu = &enc->meta_cll_obu;
> + AV1RawMetadata *md = &obu->obu.metadata;
> + AV1RawMetadataHDRCLL *cll = &md->metadata.hdr_cll;
> +
> + memset(obu, 0, sizeof(*obu));
> + obu->header.obu_type = AV1_OBU_METADATA;
> + md->metadata_type = AV1_METADATA_TYPE_HDR_CLL;
> + cll->max_cll = cllm->MaxCLL;
> + cll->max_fall = cllm->MaxFALL;
> +
> + ap->units_needed |= UNIT_CONTENT_LIGHT_LEVEL;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int init_profile(AVCodecContext *avctx,
> + VkVideoProfileInfoKHR *profile, void *pnext)
> +{
> + VkResult ret;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFVulkanContext *s = &ctx->s;
> + FFVulkanFunctions *vk = &ctx->s.vkfn;
> + FFHWBaseEncodeContext *base_ctx = &ctx->base;
> +
> + VkVideoEncodeAV1CapabilitiesKHR av1_caps = {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
> + };
> + VkVideoEncodeCapabilitiesKHR enc_caps = {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR,
> + .pNext = &av1_caps,
> + };
> + VkVideoCapabilitiesKHR caps = {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
> + .pNext = &enc_caps,
> + };
> +
> + /* In order of preference */
> + int last_supported = AV_PROFILE_UNKNOWN;
> + static const int known_profiles[] = {
> + AV_PROFILE_AV1_MAIN,
> + AV_PROFILE_AV1_HIGH,
> + AV_PROFILE_AV1_PROFESSIONAL,
> + };
> + int nb_profiles = FF_ARRAY_ELEMS(known_profiles);
> +
> + const AVPixFmtDescriptor *desc =
> av_pix_fmt_desc_get(s->frames->sw_format);
> + if (!desc)
> + return AVERROR(EINVAL);
> +
> + if (s->frames->sw_format == AV_PIX_FMT_NV12 ||
> + s->frames->sw_format == AV_PIX_FMT_P010)
> + nb_profiles = 1;
> +
> + enc->profile = (VkVideoEncodeAV1ProfileInfoKHR) {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR,
> + .pNext = pnext,
> + .stdProfile = ff_vk_av1_profile_to_vk(avctx->profile),
> + };
> + profile->pNext = &enc->profile;
> +
> + /* Set level */
> + if (avctx->level == AV_LEVEL_UNKNOWN) {
> + const AV1LevelDescriptor *level;
> + float framerate;
> +
> + if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
> + framerate = avctx->framerate.num / avctx->framerate.den;
> + else
> + framerate = 0;
> + level = ff_av1_guess_level(avctx->bit_rate, enc->seq_tier,
> + base_ctx->surface_width,
> base_ctx->surface_height,
> + enc->tile_rows * enc->tile_cols,
> + enc->tile_cols, framerate);
> + if (level) {
> + av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
> + enc->seq_level_idx = level->level_idx;
> + } else {
> + av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
> + "any normal level, using level 7.3 by default.\n");
> + enc->seq_level_idx = 19;
> + enc->seq_tier = 1;
> + }
> + } else {
> + enc->seq_level_idx = avctx->level;
> + }
> +
> + /* User has explicitly specified a profile. */
> + if (avctx->profile != AV_PROFILE_UNKNOWN)
> + return 0;
> +
> + av_log(avctx, AV_LOG_DEBUG, "Supported profiles:\n");
> + for (int i = 0; i < nb_profiles; i++) {
> + enc->profile.stdProfile = ff_vk_av1_profile_to_vk(known_profiles[i]);
> + ret = vk->GetPhysicalDeviceVideoCapabilitiesKHR(s->hwctx->phys_dev,
> + profile,
> + &caps);
> + if (ret == VK_SUCCESS) {
> + av_log(avctx, AV_LOG_DEBUG, " %s\n",
> + avcodec_profile_name(avctx->codec_id, known_profiles[i]));
> + last_supported = known_profiles[i];
> + }
> + }
> +
> + if (last_supported == AV_PROFILE_UNKNOWN) {
> + av_log(avctx, AV_LOG_ERROR, "No supported profiles for given
> format\n");
> + return AVERROR(ENOTSUP);
> + }
> +
> + enc->profile.stdProfile = ff_vk_av1_profile_to_vk(last_supported);
> + av_log(avctx, AV_LOG_VERBOSE, "Using profile %s\n",
> + avcodec_profile_name(avctx->codec_id, last_supported));
> + avctx->profile = last_supported;
> +
> + return 0;
> +}
> +
> +static int init_enc_options(AVCodecContext *avctx)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> +
> + if (avctx->rc_buffer_size)
> + enc->hrd_buffer_size = avctx->rc_buffer_size;
> + else if (avctx->rc_max_rate > 0)
> + enc->hrd_buffer_size = avctx->rc_max_rate;
> + else
> + enc->hrd_buffer_size = avctx->bit_rate;
> +
> + if (avctx->rc_initial_buffer_occupancy) {
> + if (avctx->rc_initial_buffer_occupancy > enc->hrd_buffer_size) {
> + av_log(avctx, AV_LOG_ERROR, "Invalid RC buffer settings: "
> + "must have initial buffer size (%d)
> <= "
> + "buffer size (%"PRId64").\n",
> + avctx->rc_initial_buffer_occupancy, enc->hrd_buffer_size);
> + return AVERROR(EINVAL);
> + }
> + enc->initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
> + } else {
> + enc->initial_buffer_fullness = enc->hrd_buffer_size * 3 / 4;
> + }
> +
> + if (enc->common.opts.rc_mode ==
> VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR &&
> + avctx->global_quality) {
> + enc->q_idx_p = av_clip(avctx->global_quality / FF_QP2LAMBDA, 0, 255);
> + if (fabs(avctx->i_quant_factor) > 0.0)
> + enc->q_idx_idr =
> + av_clip((fabs(avctx->i_quant_factor) * enc->q_idx_p +
> + avctx->i_quant_offset) + 0.5,
> + 0, 255);
> + else
> + enc->q_idx_idr = enc->q_idx_p;
> +
> + if (fabs(avctx->b_quant_factor) > 0.0)
> + enc->q_idx_b =
> + av_clip((fabs(avctx->b_quant_factor) * enc->q_idx_p +
> + avctx->b_quant_offset) + 0.5,
> + 0, 255);
> + else
> + enc->q_idx_b = enc->q_idx_p;
> + } else {
> + /** Arbitrary value */
> + enc->q_idx_idr = enc->q_idx_p = enc->q_idx_b = 128;
> + }
> +
> + return 0;
> +}
> +
> +static av_cold int init_sequence_headers(AVCodecContext *avctx)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFVulkanContext *s = &ctx->s;
> + FFHWBaseEncodeContext *base_ctx = &ctx->base;
> +
> + AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
> + AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
> +
> + const AVPixFmtDescriptor *desc =
> av_pix_fmt_desc_get(s->frames->sw_format);
> + if (!desc)
> + return AVERROR(EINVAL);
> +
> + seq_obu->header.obu_type = AV1_OBU_SEQUENCE_HEADER;
> + *seq = (AV1RawSequenceHeader) {
> + .seq_profile = avctx->profile,
> + .seq_force_integer_mv = seq->seq_force_screen_content_tools ?
> + AV1_SELECT_SCREEN_CONTENT_TOOLS :
> + AV1_SELECT_INTEGER_MV,
> + .frame_width_bits_minus_1 = av_log2(base_ctx->surface_width),
> + .frame_height_bits_minus_1 = av_log2(base_ctx->surface_height),
> + .max_frame_width_minus_1 = base_ctx->surface_width - 1,
> + .max_frame_height_minus_1 = base_ctx->surface_height - 1,
> + .enable_order_hint = 1,
> + .order_hint_bits_minus_1 = av_clip(av_log2(ctx->base.gop_size), 0,
> 7),
> + .use_128x128_superblock = !!(enc->caps.superblockSizes &
> VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR),
> + .color_config = (AV1RawColorConfig) {
> + .high_bitdepth = desc->comp[0].depth > 8,
> + .color_primaries = avctx->color_primaries,
> + .transfer_characteristics = avctx->color_trc,
> + .matrix_coefficients = avctx->colorspace,
> + .color_description_present_flag = (avctx->color_primaries !=
> AVCOL_PRI_UNSPECIFIED ||
> + avctx->color_trc !=
> AVCOL_TRC_UNSPECIFIED ||
> + avctx->colorspace !=
> AVCOL_SPC_UNSPECIFIED),
> + .subsampling_x = desc->log2_chroma_w,
> + .subsampling_y = desc->log2_chroma_h,
> + .chroma_sample_position = avctx->chroma_sample_location
> == AVCHROMA_LOC_LEFT ?
> + AV1_CSP_VERTICAL :
> + avctx->chroma_sample_location
> == AVCHROMA_LOC_TOPLEFT ?
> + AV1_CSP_COLOCATED :
> + AV1_CSP_UNKNOWN,
> + },
> +
> + /* Operating point */
> + .seq_tier = { enc->seq_tier },
> + .seq_level_idx = { enc->seq_level_idx },
> + .decoder_buffer_delay = { base_ctx->decode_delay },
> + .encoder_buffer_delay = { base_ctx->output_delay },
> + .operating_points_cnt_minus_1 = 1 - 1,
> + };
> +
> + return 0;
> +}
> +
> +typedef struct VulkanAV1Units {
> + StdVideoAV1SequenceHeader seq_hdr;
> + StdVideoAV1TimingInfo timing_info;
> + StdVideoAV1ColorConfig color_config;
> +
> + StdVideoEncodeAV1DecoderModelInfo decoder_model;
> + StdVideoEncodeAV1OperatingPointInfo
> operating_points[AV1_MAX_OPERATING_POINTS];
> + int nb_operating_points;
> +} VulkanAV1Units;
> +
> +static av_cold int base_unit_to_vk(AVCodecContext *avctx, VulkanAV1Units
> *vk_units)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> +
> + AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
> + AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
> +
> + StdVideoAV1SequenceHeader *seq_hdr = &vk_units->seq_hdr;
> + StdVideoAV1TimingInfo *timing_info = &vk_units->timing_info;
> + StdVideoAV1ColorConfig *color_config = &vk_units->color_config;
> +
> + StdVideoEncodeAV1OperatingPointInfo *operating_points =
> vk_units->operating_points;
> +
> + *timing_info = (StdVideoAV1TimingInfo) {
> + .flags = (StdVideoAV1TimingInfoFlags) {
> + .equal_picture_interval =
> seq->timing_info.equal_picture_interval,
> + },
> + .num_units_in_display_tick =
> seq->timing_info.num_units_in_display_tick,
> + .time_scale = seq->timing_info.time_scale,
> + .num_ticks_per_picture_minus_1 =
> seq->timing_info.num_ticks_per_picture_minus_1,
> + };
> +
> + *color_config = (StdVideoAV1ColorConfig) {
> + .flags = (StdVideoAV1ColorConfigFlags) {
> + .mono_chrome = seq->color_config.mono_chrome,
> + .color_range = seq->color_config.color_range,
> + .separate_uv_delta_q = seq->color_config.separate_uv_delta_q,
> + },
> + .BitDepth = seq->color_config.twelve_bit ? 12 :
> + seq->color_config.high_bitdepth ? 10 : 8,
> + .subsampling_x = seq->color_config.subsampling_x,
> + .subsampling_y = seq->color_config.subsampling_y,
> + .color_primaries = seq->color_config.color_primaries,
> + .transfer_characteristics =
> seq->color_config.transfer_characteristics,
> + .matrix_coefficients = seq->color_config.matrix_coefficients,
> + };
> +
> + *seq_hdr = (StdVideoAV1SequenceHeader) {
> + .flags = (StdVideoAV1SequenceHeaderFlags) {
> + .still_picture = seq->still_picture,
> + .reduced_still_picture_header =
> seq->reduced_still_picture_header,
> + .use_128x128_superblock = seq->use_128x128_superblock,
> + .enable_filter_intra = seq->enable_filter_intra,
> + .enable_intra_edge_filter = seq->enable_intra_edge_filter,
> + .enable_interintra_compound = seq->enable_interintra_compound,
> + .enable_masked_compound = seq->enable_masked_compound,
> + .enable_warped_motion = seq->enable_warped_motion,
> + .enable_dual_filter = seq->enable_dual_filter,
> + .enable_order_hint = seq->enable_order_hint,
> + .enable_jnt_comp = seq->enable_jnt_comp,
> + .enable_ref_frame_mvs = seq->enable_ref_frame_mvs,
> + .frame_id_numbers_present_flag =
> seq->frame_id_numbers_present_flag,
> + .enable_superres = seq->enable_superres,
> + .enable_cdef = seq->enable_cdef,
> + .enable_restoration = seq->enable_restoration,
> + .film_grain_params_present = seq->film_grain_params_present,
> + .timing_info_present_flag = seq->timing_info_present_flag,
> + .initial_display_delay_present_flag =
> seq->initial_display_delay_present_flag,
> + },
> + .seq_profile = seq->seq_profile,
> + .frame_width_bits_minus_1 = seq->frame_width_bits_minus_1,
> + .frame_height_bits_minus_1 = seq->frame_height_bits_minus_1,
> + .max_frame_width_minus_1 = seq->max_frame_width_minus_1,
> + .max_frame_height_minus_1 = seq->max_frame_height_minus_1,
> + .delta_frame_id_length_minus_2 = seq->delta_frame_id_length_minus_2,
> + .additional_frame_id_length_minus_1 =
> seq->additional_frame_id_length_minus_1,
> + .order_hint_bits_minus_1 = seq->order_hint_bits_minus_1,
> + .seq_force_integer_mv = seq->seq_force_integer_mv,
> + .seq_force_screen_content_tools =
> seq->seq_force_screen_content_tools,
> + .pTimingInfo = timing_info,
> + .pColorConfig = color_config,
> + };
> +
> + for (int i = 0; i <= seq->operating_points_cnt_minus_1; i++) {
> + operating_points[i] = (StdVideoEncodeAV1OperatingPointInfo) {
> + .flags = (StdVideoEncodeAV1OperatingPointInfoFlags) {
> + .decoder_model_present_for_this_op =
> seq->decoder_model_present_for_this_op[i],
> + .low_delay_mode_flag = seq->low_delay_mode_flag[i],
> + .initial_display_delay_present_for_this_op =
> seq->initial_display_delay_present_for_this_op[i],
> + /* Reserved */
> + },
> + .operating_point_idc = seq->operating_point_idc[i],
> + .seq_level_idx = seq->seq_level_idx[i],
> + .seq_tier = seq->seq_tier[i],
> + .decoder_buffer_delay = seq->decoder_buffer_delay[i],
> + .encoder_buffer_delay = seq->encoder_buffer_delay[i],
> + .initial_display_delay_minus_1 =
> seq->initial_display_delay_minus_1[i],
> + };
> + }
> + vk_units->nb_operating_points = seq->operating_points_cnt_minus_1 + 1;
> +
> + return 0;
> +}
> +
> +static int create_session_params(AVCodecContext *avctx)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFVulkanContext *s = &ctx->s;
> + FFVulkanFunctions *vk = &ctx->s.vkfn;
> +
> + VulkanAV1Units vk_units = { 0 };
> +
> + VkVideoEncodeAV1SessionParametersCreateInfoKHR av1_params;
> +
> + /* Convert it to Vulkan */
> + err = base_unit_to_vk(avctx, &vk_units);
> + if (err < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Unable to convert sequence header to
> Vulkan: %s\n",
> + av_err2str(err));
> + return err;
> + }
> +
> + /* Destroy the session params */
> + if (ctx->session_params)
> + vk->DestroyVideoSessionParametersKHR(s->hwctx->act_dev,
> + ctx->session_params,
> + s->hwctx->alloc);
> +
> + av1_params = (VkVideoEncodeAV1SessionParametersCreateInfoKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
> + .pStdSequenceHeader = &vk_units.seq_hdr,
> + .pStdDecoderModelInfo = &vk_units.decoder_model,
> + .pStdOperatingPoints = vk_units.operating_points,
> + .stdOperatingPointCount = vk_units.nb_operating_points,
> + };
> +
> + return ff_vulkan_encode_create_session_params(avctx, ctx, &av1_params);
> +}
> +
> +static int parse_feedback_units(AVCodecContext *avctx,
> + const uint8_t *data, size_t size)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
> + AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
> +
> + CodedBitstreamContext *cbs;
> + CodedBitstreamFragment obu = { 0 };
> +
> + err = ff_cbs_init(&cbs, AV_CODEC_ID_AV1, avctx);
> + if (err < 0)
> + return err;
> +
> + err = ff_cbs_read(cbs, &obu, data, size);
> + if (err < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Unable to parse feedback units, bad
> drivers: %s\n",
> + av_err2str(err));
> + return err;
> + }
> +
> + /* If PPS has an override, just copy it entirely. */
> + for (int i = 0; i < obu.nb_units; i++) {
> + if (obu.units[i].type == AV1_OBU_SEQUENCE_HEADER) {
> + AV1RawOBU *f_seq_obu = obu.units[i].content;
> + AV1RawSequenceHeader *f_seq = &f_seq_obu->obu.sequence_header;
> + seq->frame_width_bits_minus_1 = f_seq->frame_width_bits_minus_1;
> + seq->frame_height_bits_minus_1 =
> f_seq->frame_height_bits_minus_1;
> + seq->max_frame_width_minus_1 = f_seq->max_frame_width_minus_1;
> + seq->max_frame_height_minus_1 = f_seq->max_frame_height_minus_1;
> + seq->seq_choose_screen_content_tools =
> f_seq->seq_choose_screen_content_tools;
> + seq->seq_force_screen_content_tools =
> f_seq->seq_force_screen_content_tools;
> + seq->seq_choose_integer_mv = f_seq->seq_choose_integer_mv;
> + seq->seq_force_integer_mv = f_seq->seq_force_integer_mv;
> + }
> + }
> +
> + ff_cbs_fragment_free(&obu);
> + ff_cbs_close(&cbs);
> +
> + return 0;
> +}
> +
> +static int init_base_units(AVCodecContext *avctx)
> +{
> + int err;
> + VkResult ret;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFVulkanContext *s = &ctx->s;
> + FFVulkanFunctions *vk = &ctx->s.vkfn;
> +
> + VkVideoEncodeSessionParametersGetInfoKHR params_info;
> + VkVideoEncodeSessionParametersFeedbackInfoKHR params_feedback;
> +
> + void *data = NULL;
> + size_t data_size = 0;
> +
> + /* Generate SPS/PPS unit info */
> + err = init_sequence_headers(avctx);
> + if (err < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Unable to initialize sequence header:
> %s\n",
> + av_err2str(err));
> + return err;
> + }
> +
> + /* Create session parameters from them */
> + err = create_session_params(avctx);
> + if (err < 0)
> + return err;
> +
> + params_info = (VkVideoEncodeSessionParametersGetInfoKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR,
> + .videoSessionParameters = ctx->session_params,
> + };
> + params_feedback = (VkVideoEncodeSessionParametersFeedbackInfoKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
> + };
> +
> + ret = vk->GetEncodedVideoSessionParametersKHR(s->hwctx->act_dev,
> ¶ms_info,
> + ¶ms_feedback,
> + &data_size, data);
> + if (ret == VK_INCOMPLETE ||
> + (ret == VK_SUCCESS) && (data_size > 0)) {
> + data = av_mallocz(data_size);
> + if (!data)
> + return AVERROR(ENOMEM);
> + } else {
> + av_log(avctx, AV_LOG_ERROR, "Unable to get feedback for AV1 sequence
> header = %lu\n",
> + data_size);
> + return err;
> + }
> +
> + ret = vk->GetEncodedVideoSessionParametersKHR(s->hwctx->act_dev,
> ¶ms_info,
> + ¶ms_feedback,
> + &data_size, data);
> + if (ret != VK_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "Error writing feedback units\n");
> + return err;
> + }
> +
> + av_log(avctx, AV_LOG_VERBOSE, "Feedback units written, overrides: %i\n",
> + params_feedback.hasOverrides);
> +
> + params_feedback.hasOverrides = 1;
> +
> + /* No need to sync any overrides */
> + if (!params_feedback.hasOverrides)
> + return 0;
> +
> + /* Parse back tne units and override */
> + err = parse_feedback_units(avctx, data, data_size);
> + if (err < 0)
> + return err;
> +
> + /* Create final session parameters */
> + err = create_session_params(avctx);
> + if (err < 0)
> + return err;
> +
> + return 0;
> +}
> +
> +static int vulkan_encode_av1_add_obu(AVCodecContext *avctx,
> + CodedBitstreamFragment *au,
> + uint8_t type, void *obu_unit)
> +{
> + int err;
> +
> + err = ff_cbs_insert_unit_content(au, -1,
> + type, obu_unit, NULL);
> + if (err < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to add OBU unit: "
> + "type = %d.\n", type);
> + return err;
> + }
> +
> + return err;
> +}
> +
> +static int vulkan_encode_av1_write_obu(AVCodecContext *avctx,
> + uint8_t *data, size_t *data_len,
> + CodedBitstreamFragment *obu)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + int ret;
> +
> + ret = ff_cbs_write_fragment_data(enc->cbs, obu);
> + if (ret < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
> + return ret;
> + }
> +
> + memcpy(data, obu->data, obu->data_size);
> + *data_len = obu->data_size;
> +
> + return 0;
> +}
> +
> +static int write_sequence_header(AVCodecContext *avctx,
> + FFHWBaseEncodePicture *base_pic,
> + uint8_t *data, size_t *data_len)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + CodedBitstreamFragment *obu = &enc->current_access_unit;
> +
> + err = vulkan_encode_av1_add_obu(avctx, obu,
> + AV1_OBU_SEQUENCE_HEADER,
> &enc->seq_hdr_obu);
> + if (err < 0)
> + goto fail;
> +
> + err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
> +
> +fail:
> + ff_cbs_fragment_reset(obu);
> + return err;
> +}
> +
> +static int write_extra_headers(AVCodecContext *avctx,
> + FFHWBaseEncodePicture *base_pic,
> + uint8_t *data, size_t *data_len)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + VulkanEncodeAV1Picture *ap = base_pic->codec_priv;
> + CodedBitstreamFragment *obu = &enc->current_access_unit;
> +
> + if (ap->units_needed & AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
> + err = vulkan_encode_av1_add_obu(avctx, obu,
> + AV1_OBU_METADATA,
> + &enc->meta_mastering_obu);
> + if (err < 0)
> + goto fail;
> + }
> +
> + if (ap->units_needed & UNIT_CONTENT_LIGHT_LEVEL) {
> + err = vulkan_encode_av1_add_obu(avctx, obu,
> + AV1_OBU_METADATA,
> + &enc->meta_cll_obu);
> + if (err < 0)
> + goto fail;
> + }
> +
> + if (ap->units_needed) {
> + err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
> + if (err < 0)
> + goto fail;
> + } else {
> + *data_len = 0;
> + }
> +
> +fail:
> + ff_cbs_fragment_reset(obu);
> + return err;
> +}
> +
> +static int write_padding(AVCodecContext *avctx, uint32_t padding,
> + uint8_t *data, size_t *data_len)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + CodedBitstreamFragment *obu = &enc->current_access_unit;
> +
> + AV1RawOBU padding_obu = { 0 };
> + AV1RawPadding *raw_padding = &padding_obu.obu.padding;
> +
> + if (!padding)
> + padding = 16;
> +
> + /* 2 byte header + 1 byte trailing bits */
> + padding_obu.header.obu_type = AV1_OBU_PADDING;
> + *raw_padding = (AV1RawPadding) {
> + .payload = enc->padding_payload,
> + .payload_size = padding,
> + };
> +
> + err = vulkan_encode_av1_add_obu(avctx, obu, AV1_OBU_PADDING,
> &padding_obu);
> + if (err < 0)
> + goto fail;
> +
> + err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
> +fail:
> + ff_cbs_fragment_reset(obu);
> + return err;
> +}
> +
> +static const FFVulkanCodec enc_cb = {
> + .flags = FF_HW_FLAG_B_PICTURES |
> + FF_HW_FLAG_B_PICTURE_REFERENCES |
> + VK_ENC_FLAG_NO_DELAY |
> + FF_HW_FLAG_SLICE_CONTROL,
> + .picture_priv_data_size = sizeof(VulkanEncodeAV1Picture),
> + .filler_header_size = 4,
> + .init_profile = init_profile,
> + .init_pic_rc = init_pic_rc,
> + .init_pic_params = init_pic_params,
> + .write_sequence_headers = write_sequence_header,
> + .write_extra_headers = write_extra_headers,
> + .write_filler = write_padding,
> +};
> +
> +static av_cold int vulkan_encode_av1_init(AVCodecContext *avctx)
> +{
> + int err;
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + FFVulkanEncodeContext *ctx = &enc->common;
> + FFVulkanContext *s = &ctx->s;
> + FFHWBaseEncodeContext *base_ctx = &ctx->base;
> + int flags;
> +
> + if (avctx->profile == AV_PROFILE_UNKNOWN)
> + avctx->profile = enc->common.opts.profile;
> +
> + enc->caps = (VkVideoEncodeAV1CapabilitiesKHR) {
> + .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
> + };
> +
> + enc->quality_props = (VkVideoEncodeAV1QualityLevelPropertiesKHR) {
> + .sType =
> VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR,
> + };
> +
> + err = ff_vulkan_encode_init(avctx, &enc->common,
> + &ff_vk_enc_av1_desc, &enc_cb,
> + &enc->caps, &enc->quality_props);
> + if (err < 0)
> + return err;
> +
> + av_log(avctx, AV_LOG_VERBOSE, "AV1 encoder capabilities:\n");
> + av_log(avctx, AV_LOG_VERBOSE, " Standard capability flags:\n");
> + av_log(avctx, AV_LOG_VERBOSE, "
> per_rate_control_group_min_max_q_index: %i\n",
> + !!(enc->caps.flags &
> VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " generate_obu_extension_header:
> %i\n",
> + !!(enc->caps.flags &
> VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " primary_reference_cdf_only: %i\n",
> + !!(enc->caps.flags &
> VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " frame_size_override: %i\n",
> + !!(enc->caps.flags &
> VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " motion_vector_scaling: %i\n",
> + !!(enc->caps.flags &
> VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " Capabilities:\n");
> + av_log(avctx, AV_LOG_VERBOSE, " 64x64 superblocks: %i\n",
> + !!(enc->caps.superblockSizes &
> VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " 128x128 superblocks: %i\n",
> + !!(enc->caps.superblockSizes &
> VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR));
> + av_log(avctx, AV_LOG_VERBOSE, " maxSingleReferenceCount: %i\n",
> + enc->caps.maxSingleReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, " singleReferenceNameMask: 0x%x\n",
> + enc->caps.singleReferenceNameMask);
> + av_log(avctx, AV_LOG_VERBOSE, "
> maxUnidirectionalCompoundReferenceCount: %i\n",
> + enc->caps.maxUnidirectionalCompoundReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, "
> maxUnidirectionalCompoundGroup1ReferenceCount: %i\n",
> + enc->caps.maxUnidirectionalCompoundGroup1ReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, "
> unidirectionalCompoundReferenceNameMask: 0x%x\n",
> + enc->caps.unidirectionalCompoundReferenceNameMask);
> + av_log(avctx, AV_LOG_VERBOSE, "
> maxBidirectionalCompoundReferenceCount: %i\n",
> + enc->caps.maxBidirectionalCompoundReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, "
> maxBidirectionalCompoundGroup1ReferenceCount: %i\n",
> + enc->caps.maxBidirectionalCompoundGroup1ReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, "
> maxBidirectionalCompoundGroup2ReferenceCount: %i\n",
> + enc->caps.maxBidirectionalCompoundGroup2ReferenceCount);
> + av_log(avctx, AV_LOG_VERBOSE, "
> bidirectionalCompoundReferenceNameMask: 0x%x\n",
> + enc->caps.bidirectionalCompoundReferenceNameMask);
> + av_log(avctx, AV_LOG_VERBOSE, " maxTemporalLayerCount: %i\n",
> + enc->caps.maxTemporalLayerCount);
> + av_log(avctx, AV_LOG_VERBOSE, " maxSpatialLayerCount: %i\n",
> + enc->caps.maxSpatialLayerCount);
> + av_log(avctx, AV_LOG_VERBOSE, " maxOperatingPoints: %i\n",
> + enc->caps.maxOperatingPoints);
> + av_log(avctx, AV_LOG_VERBOSE, " min/max Qindex: [%i, %i]\n",
> + enc->caps.minQIndex, enc->caps.maxQIndex);
> + av_log(avctx, AV_LOG_VERBOSE, " prefersGopRemainingFrames: %i\n",
> + enc->caps.prefersGopRemainingFrames);
> + av_log(avctx, AV_LOG_VERBOSE, " requiresGopRemainingFrames: %i\n",
> + enc->caps.requiresGopRemainingFrames);
> + av_log(avctx, AV_LOG_VERBOSE, " maxLevel: %i\n",
> + enc->caps.maxLevel);
> + av_log(avctx, AV_LOG_VERBOSE, " codedPictureAlignment: %ix%i\n",
> + enc->caps.codedPictureAlignment.width,
> enc->caps.codedPictureAlignment.height);
> + av_log(avctx, AV_LOG_VERBOSE, " maxTiles: %ix%i\n",
> + enc->caps.maxTiles.width, enc->caps.maxTiles.height);
> + av_log(avctx, AV_LOG_VERBOSE, " Tile size: %ix%i to %ix%i\n",
> + enc->caps.minTileSize.width, enc->caps.minTileSize.height,
> + enc->caps.maxTileSize.width, enc->caps.maxTileSize.height);
> +
> + err = init_enc_options(avctx);
> + if (err < 0)
> + return err;
> +
> + flags = ctx->codec->flags;
> + err = ff_hw_base_init_gop_structure(base_ctx, avctx,
> + ctx->caps.maxDpbSlots,
> +
> enc->caps.maxBidirectionalCompoundReferenceCount,
> + flags, 0);
> + if (err < 0)
> + return err;
> +
> + base_ctx->output_delay = base_ctx->b_per_p;
> + base_ctx->decode_delay = base_ctx->max_b_depth;
> +
> + /* Create units and session parameters */
> + err = init_base_units(avctx);
> + if (err < 0)
> + return err;
> +
> + /* Init CBS */
> + err = ff_cbs_init(&enc->cbs, AV_CODEC_ID_AV1, avctx);
> + if (err < 0)
> + return err;
> +
> + if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
> + uint8_t data[4096];
> + size_t data_len = sizeof(data);
> +
> + err = write_sequence_header(avctx, NULL, data, &data_len);
> + if (err < 0) {
> + av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
> + "for extradata: %d.\n", err);
> + return err;
> + } else {
> + avctx->extradata_size = data_len;
> + avctx->extradata = av_mallocz(avctx->extradata_size +
> + AV_INPUT_BUFFER_PADDING_SIZE);
> + if (!avctx->extradata) {
> + err = AVERROR(ENOMEM);
> + return err;
> + }
> + memcpy(avctx->extradata, data, avctx->extradata_size);
> + }
> + }
> +
> + enc->padding_payload =
> av_mallocz(2*ctx->caps.minBitstreamBufferOffsetAlignment);
> + if (!enc->padding_payload)
> + return AVERROR(ENOMEM);
> +
> + memset(enc->padding_payload, 0xaa,
> 2*ctx->caps.minBitstreamBufferOffsetAlignment);
> +
> + return 0;
> +}
> +
> +static av_cold int vulkan_encode_av1_close(AVCodecContext *avctx)
> +{
> + VulkanEncodeAV1Context *enc = avctx->priv_data;
> + av_free(enc->padding_payload);
> + ff_vulkan_encode_uninit(&enc->common);
> + return 0;
> +}
> +
> +#define OFFSET(x) offsetof(VulkanEncodeAV1Context, x)
> +#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
> +static const AVOption vulkan_encode_av1_options[] = {
> + HW_BASE_ENCODE_COMMON_OPTIONS,
> + VULKAN_ENCODE_COMMON_OPTIONS,
> +
> + { "profile", "Set profile",
> + OFFSET(common.opts.profile), AV_OPT_TYPE_INT,
> + { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, FLAGS,
> .unit = "profile" },
> +
> +#define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
> + { .i64 = value }, 0, 0, FLAGS, .unit = "profile"
> + { PROFILE("main", AV_PROFILE_AV1_MAIN) },
> + { PROFILE("high", AV_PROFILE_AV1_HIGH) },
> + { PROFILE("professional", AV_PROFILE_AV1_PROFESSIONAL) },
> +#undef PROFILE
> +
> + { "tier", "Set tier (seq_tier)",
> + OFFSET(common.opts.tier), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS,
> .unit = "tier" },
> + { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FLAGS,
> .unit = "tier" },
> + { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, FLAGS,
> .unit = "tier" },
> +
> + { "level", "Set level (level_idc)",
> + OFFSET(common.opts.level), AV_OPT_TYPE_INT,
> + { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, .unit =
> "level" },
> +
> +#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
> + { .i64 = value }, 0, 0, FLAGS, .unit = "level"
> + { LEVEL("20", 0) },
> + { LEVEL("21", 1) },
> + { LEVEL("22", 2) },
> + { LEVEL("23", 3) },
> + { LEVEL("30", 4) },
> + { LEVEL("31", 5) },
> + { LEVEL("32", 6) },
> + { LEVEL("33", 7) },
> + { LEVEL("40", 8) },
> + { LEVEL("41", 9) },
> + { LEVEL("42", 10) },
> + { LEVEL("43", 11) },
> + { LEVEL("50", 12) },
> + { LEVEL("51", 13) },
> + { LEVEL("52", 14) },
> + { LEVEL("53", 15) },
> + { LEVEL("60", 16) },
> + { LEVEL("61", 17) },
> + { LEVEL("62", 18) },
> + { LEVEL("63", 19) },
> + { LEVEL("70", 20) },
> + { LEVEL("71", 21) },
> + { LEVEL("72", 22) },
> + { LEVEL("73", 23) },
> +#undef LEVEL
> +
> + { "units", "Set units to include", OFFSET(unit_elems),
> AV_OPT_TYPE_FLAGS, { .i64 = UNIT_MASTERING_DISPLAY | UNIT_CONTENT_LIGHT_LEVEL
> }, 0, INT_MAX, FLAGS, "units" },
> + { "hdr", "Include HDR metadata for mastering display colour
> volume and content light level information", 0, AV_OPT_TYPE_CONST, { .i64 =
> UNIT_MASTERING_DISPLAY | UNIT_CONTENT_LIGHT_LEVEL }, INT_MIN, INT_MAX, FLAGS,
> "units" },
> +
> + { NULL },
> +};
> +
> +static const FFCodecDefault vulkan_encode_av1_defaults[] = {
> + { "b", "0" },
> + { "bf", "2" },
> + { "g", "300" },
> + { "qmin", "1" },
> + { "qmax", "255" },
> + { NULL },
> +};
> +
> +static const AVClass vulkan_encode_av1_class = {
> + .class_name = "av1_vulkan",
> + .item_name = av_default_item_name,
> + .option = vulkan_encode_av1_options,
> + .version = LIBAVUTIL_VERSION_INT,
> +};
> +
> +const FFCodec ff_av1_vulkan_encoder = {
> + .p.name = "av1_vulkan",
> + CODEC_LONG_NAME("AV1 (Vulkan)"),
> + .p.type = AVMEDIA_TYPE_VIDEO,
> + .p.id = AV_CODEC_ID_AV1,
> + .priv_data_size = sizeof(VulkanEncodeAV1Context),
> + .init = &vulkan_encode_av1_init,
> + FF_CODEC_RECEIVE_PACKET_CB(&ff_vulkan_encode_receive_packet),
> + .close = &vulkan_encode_av1_close,
> + .p.priv_class = &vulkan_encode_av1_class,
> + .p.capabilities = AV_CODEC_CAP_DELAY |
> + AV_CODEC_CAP_HARDWARE |
> + AV_CODEC_CAP_DR1 |
> + AV_CODEC_CAP_ENCODER_FLUSH |
> + AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
> + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
> + .defaults = vulkan_encode_av1_defaults,
> + .p.pix_fmts = (const enum AVPixelFormat[]) {
> + AV_PIX_FMT_VULKAN,
> + AV_PIX_FMT_NONE,
> + },
> + .hw_configs = ff_vulkan_encode_hw_configs,
> + .p.wrapper_name = "vulkan",
> +};
> diff --git a/libavcodec/vulkan_video.c b/libavcodec/vulkan_video.c
> index 1d44406aa1..7b0f2f4202 100644
> --- a/libavcodec/vulkan_video.c
> +++ b/libavcodec/vulkan_video.c
> @@ -207,6 +207,37 @@ int ff_vk_h265_level_to_av(StdVideoH265LevelIdc level)
> }
> }
>
> +int ff_vk_av1_level_to_av(StdVideoAV1Level level)
> +{
> + switch (level) {
> + case STD_VIDEO_AV1_LEVEL_2_0: return 20;
> + case STD_VIDEO_AV1_LEVEL_2_1: return 21;
> + case STD_VIDEO_AV1_LEVEL_2_2: return 22;
> + case STD_VIDEO_AV1_LEVEL_2_3: return 23;
> + case STD_VIDEO_AV1_LEVEL_3_0: return 30;
> + case STD_VIDEO_AV1_LEVEL_3_1: return 31;
> + case STD_VIDEO_AV1_LEVEL_3_2: return 32;
> + case STD_VIDEO_AV1_LEVEL_3_3: return 33;
> + case STD_VIDEO_AV1_LEVEL_4_0: return 40;
> + case STD_VIDEO_AV1_LEVEL_4_1: return 41;
> + case STD_VIDEO_AV1_LEVEL_4_2: return 42;
> + case STD_VIDEO_AV1_LEVEL_4_3: return 43;
> + case STD_VIDEO_AV1_LEVEL_5_0: return 50;
> + case STD_VIDEO_AV1_LEVEL_5_1: return 51;
> + case STD_VIDEO_AV1_LEVEL_5_2: return 52;
> + case STD_VIDEO_AV1_LEVEL_5_3: return 53;
> + case STD_VIDEO_AV1_LEVEL_6_0: return 60;
> + case STD_VIDEO_AV1_LEVEL_6_1: return 61;
> + case STD_VIDEO_AV1_LEVEL_6_2: return 62;
> + case STD_VIDEO_AV1_LEVEL_6_3: return 63;
> + case STD_VIDEO_AV1_LEVEL_7_0: return 70;
> + case STD_VIDEO_AV1_LEVEL_7_1: return 71;
> + case STD_VIDEO_AV1_LEVEL_7_2: return 72;
> + default:
> + case STD_VIDEO_AV1_LEVEL_7_3: return 73;
> + }
> +}
> +
> StdVideoH265LevelIdc ff_vk_h265_level_to_vk(int level_idc)
> {
> switch (level_idc) {
> @@ -226,6 +257,37 @@ StdVideoH265LevelIdc ff_vk_h265_level_to_vk(int
> level_idc)
> }
> }
>
> +StdVideoAV1Level ff_vk_av1_level_to_vk(int level)
> +{
> + switch (level) {
> + case 20: return STD_VIDEO_AV1_LEVEL_2_0;
> + case 21: return STD_VIDEO_AV1_LEVEL_2_1;
> + case 22: return STD_VIDEO_AV1_LEVEL_2_2;
> + case 23: return STD_VIDEO_AV1_LEVEL_2_3;
> + case 30: return STD_VIDEO_AV1_LEVEL_3_0;
> + case 31: return STD_VIDEO_AV1_LEVEL_3_1;
> + case 32: return STD_VIDEO_AV1_LEVEL_3_2;
> + case 33: return STD_VIDEO_AV1_LEVEL_3_3;
> + case 40: return STD_VIDEO_AV1_LEVEL_4_0;
> + case 41: return STD_VIDEO_AV1_LEVEL_4_1;
> + case 42: return STD_VIDEO_AV1_LEVEL_4_2;
> + case 43: return STD_VIDEO_AV1_LEVEL_4_3;
> + case 50: return STD_VIDEO_AV1_LEVEL_5_0;
> + case 51: return STD_VIDEO_AV1_LEVEL_5_1;
> + case 52: return STD_VIDEO_AV1_LEVEL_5_2;
> + case 53: return STD_VIDEO_AV1_LEVEL_5_3;
> + case 60: return STD_VIDEO_AV1_LEVEL_6_0;
> + case 61: return STD_VIDEO_AV1_LEVEL_6_1;
> + case 62: return STD_VIDEO_AV1_LEVEL_6_2;
> + case 63: return STD_VIDEO_AV1_LEVEL_6_3;
> + case 70: return STD_VIDEO_AV1_LEVEL_7_0;
> + case 71: return STD_VIDEO_AV1_LEVEL_7_1;
> + case 72: return STD_VIDEO_AV1_LEVEL_7_2;
> + default:
> + case 73: return STD_VIDEO_AV1_LEVEL_7_3;
> + }
> +}
> +
> StdVideoH264ProfileIdc ff_vk_h264_profile_to_vk(int profile)
> {
> switch (profile) {
> @@ -247,6 +309,47 @@ StdVideoH265ProfileIdc ff_vk_h265_profile_to_vk(int
> profile)
> }
> }
>
> +StdVideoAV1Profile ff_vk_av1_profile_to_vk(int profile)
> +{
> + switch (profile) {
> + case AV_PROFILE_AV1_MAIN: return STD_VIDEO_AV1_PROFILE_MAIN;
> + case AV_PROFILE_AV1_HIGH: return STD_VIDEO_AV1_PROFILE_HIGH;
> + case AV_PROFILE_AV1_PROFESSIONAL: return
> STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
> + default: return STD_VIDEO_AV1_PROFILE_INVALID;
> + }
> +}
> +
> +int ff_vk_h264_profile_to_av(StdVideoH264ProfileIdc profile)
> +{
> + switch (profile) {
> + case STD_VIDEO_H264_PROFILE_IDC_BASELINE: return
> AV_PROFILE_H264_CONSTRAINED_BASELINE;
> + case STD_VIDEO_H264_PROFILE_IDC_MAIN: return AV_PROFILE_H264_MAIN;
> + case STD_VIDEO_H264_PROFILE_IDC_HIGH: return AV_PROFILE_H264_HIGH;
> + case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: return
> AV_PROFILE_H264_HIGH_444_PREDICTIVE;
> + default: return AV_PROFILE_UNKNOWN;
> + }
> +}
> +
> +int ff_vk_h265_profile_to_av(StdVideoH264ProfileIdc profile)
> +{
> + switch (profile) {
> + case STD_VIDEO_H265_PROFILE_IDC_MAIN: return AV_PROFILE_HEVC_MAIN;
> + case STD_VIDEO_H265_PROFILE_IDC_MAIN_10: return AV_PROFILE_HEVC_MAIN_10;
> + case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: return
> AV_PROFILE_HEVC_REXT;
> + default: return AV_PROFILE_UNKNOWN;
> + }
> +}
> +
> +int ff_vk_av1_profile_to_av(StdVideoH264ProfileIdc profile)
> +{
> + switch (profile) {
> + case STD_VIDEO_AV1_PROFILE_MAIN: return AV_PROFILE_AV1_MAIN;
> + case STD_VIDEO_AV1_PROFILE_HIGH: return AV_PROFILE_AV1_HIGH;
> + case STD_VIDEO_AV1_PROFILE_PROFESSIONAL: return
> AV_PROFILE_AV1_PROFESSIONAL;
> + default: return AV_PROFILE_UNKNOWN;
> + }
> +}
> +
> int ff_vk_create_view(FFVulkanContext *s, FFVkVideoCommon *common,
> VkImageView *view, VkImageAspectFlags *aspect,
> AVVkFrame *src, VkFormat vkf, int is_dpb)
> diff --git a/libavcodec/vulkan_video.h b/libavcodec/vulkan_video.h
> index 0348c3b804..4b67b17247 100644
> --- a/libavcodec/vulkan_video.h
> +++ b/libavcodec/vulkan_video.h
> @@ -68,9 +68,11 @@ VkVideoComponentBitDepthFlagBitsKHR
> ff_vk_depth_from_av_depth(int depth);
> */
> int ff_vk_h264_level_to_av(StdVideoH264LevelIdc level);
> int ff_vk_h265_level_to_av(StdVideoH265LevelIdc level);
> +int ff_vk_av1_level_to_av(StdVideoAV1Level level);
>
> StdVideoH264LevelIdc ff_vk_h264_level_to_vk(int level_idc);
> StdVideoH265LevelIdc ff_vk_h265_level_to_vk(int level_idc);
> +StdVideoAV1Level ff_vk_av1_level_to_vk(int level);
>
> /**
> * Convert profile from/to AV to Vulkan
> @@ -78,6 +80,11 @@ StdVideoH265LevelIdc ff_vk_h265_level_to_vk(int level_idc);
> StdVideoH264ProfileIdc ff_vk_h264_profile_to_vk(int profile);
> StdVideoH265ProfileIdc ff_vk_h265_profile_to_vk(int profile);
>
> +StdVideoAV1Profile ff_vk_av1_profile_to_vk(int profile);
> +int ff_vk_h264_profile_to_av(StdVideoH264ProfileIdc profile);
> +int ff_vk_h265_profile_to_av(StdVideoH264ProfileIdc profile);
> +int ff_vk_av1_profile_to_av(StdVideoH264ProfileIdc profile);
Can you please stop adding functions that are unused?
> +
> /**
> * Creates image views for video frames.
> */
> diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c
> index 8823af0175..df132f942f 100644
> --- a/libavutil/hwcontext_vulkan.c
> +++ b/libavutil/hwcontext_vulkan.c
> @@ -647,6 +647,7 @@ static const VulkanOptExtension optional_device_exts[] = {
> { VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_DECODE_H264 },
> { VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_ENCODE_H265 },
> { VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_DECODE_H265 },
> + { VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_ENCODE_AV1 },
> { VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_DECODE_AV1 },
> };
>
> @@ -1530,6 +1531,7 @@ static int setup_queue_families(AVHWDeviceContext *ctx,
> VkDeviceCreateInfo *cd)
> PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR,
> VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR);
> PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR,
> VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR);
>
> + PICK_QF(VK_QUEUE_VIDEO_ENCODE_BIT_KHR,
> VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR);
> PICK_QF(VK_QUEUE_VIDEO_DECODE_BIT_KHR,
> VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR);
>
> av_free(qf);
> diff --git a/libavutil/vulkan_functions.h b/libavutil/vulkan_functions.h
> index cd61d71577..6b826f8ba9 100644
> --- a/libavutil/vulkan_functions.h
> +++ b/libavutil/vulkan_functions.h
> @@ -62,6 +62,7 @@ typedef uint64_t FFVulkanExtensions;
> #define FF_VK_EXT_VIDEO_ENCODE_QUEUE (1ULL << 50) /*
> VK_KHR_video_encode_queue */
> #define FF_VK_EXT_VIDEO_ENCODE_H264 (1ULL << 51) /*
> VK_KHR_video_encode_h264 */
> #define FF_VK_EXT_VIDEO_ENCODE_H265 (1ULL << 52) /*
> VK_KHR_video_encode_h265 */
> +#define FF_VK_EXT_VIDEO_ENCODE_AV1 (1ULL << 53) /*
> VK_KHR_video_encode_av1 */
> f
> #define FF_VK_EXT_PORTABILITY_SUBSET (1ULL << 62)
> #define FF_VK_EXT_NO_FLAG (1ULL << 63)
> diff --git a/libavutil/vulkan_loader.h b/libavutil/vulkan_loader.h
> index 3641fcb22e..fe0e0655bb 100644
> --- a/libavutil/vulkan_loader.h
> +++ b/libavutil/vulkan_loader.h
> @@ -77,6 +77,7 @@ static inline uint64_t ff_vk_extensions_to_mask(const char
> * const *extensions,
> { VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_DECODE_AV1 },
> { VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
> FF_VK_EXT_PUSH_DESCRIPTOR },
> { VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME,
> FF_VK_EXT_EXPECT_ASSUME },
> + { VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME,
> FF_VK_EXT_VIDEO_ENCODE_AV1 },
> };
>
> FFVulkanExtensions mask = 0x0;
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
To unsubscribe, visit link above, or email
ffmpeg-devel-requ...@ffmpeg.org with subject "unsubscribe".
