From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by master.gitmailbox.com (Postfix) with ESMTPS id C97074E232 for ; Mon, 10 Mar 2025 03:17:26 +0000 (UTC) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id EB4F768E7F6; Mon, 10 Mar 2025 05:17:22 +0200 (EET) Received: from vidala.pars.ee (vidala.pars.ee [116.203.72.101]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 91E8168E7D8 for ; Mon, 10 Mar 2025 05:17:16 +0200 (EET) DKIM-Signature: v=1; a=rsa-sha256; s=202405r; d=lynne.ee; c=relaxed/relaxed; h=Message-ID:Date:Subject:To:From; t=1741576635; bh=2ppEaFn0gAtl7sCov1ciA0P 7coYlDe3lThWYxXVx+L0=; b=OqNSB+cZ96InItE1rxHUHNSaLsF6E57j3c7PWln/PmKo2ts2ah pf0d/Y8GssAABAFq2/X+8yhRhn2aRk70Q6irQIA3Tu02UjxzSKFXBY+62Himf4pMUiqRDQH4eql 8vYzR8dRNPKaMsf+L28z2u8m/3VY3R3xkgBjhizSYT7hqSXmyjhyKJeSkStvhAKuQse9/4bWRbC Mw+3rjyFpkaC5D3K3yVB94x8NtmNsLBggVxxHSBpfAFVkPAMghYDMBZdCZ5ZE1QAaQjZMD+rJvk 5J074zVtr4qVu0hvKcH3jgj2yUXoEH+87Onzro4HhRfYG7WRRpfyvTADI41tA7NAbzA==; DKIM-Signature: v=1; a=ed25519-sha256; s=202405e; d=lynne.ee; c=relaxed/relaxed; h=Message-ID:Date:Subject:To:From; t=1741576635; bh=2ppEaFn0gAtl7sCov1ciA0P 7coYlDe3lThWYxXVx+L0=; b=pR+pzMXDvPrenBiYYXaEr4goubMlciw3CewlPjC/IL/Vb4vJE1 iAWb+1pzVrW6JlRtKHtME8ummOpuXcW1MKBA==; From: Lynne To: ffmpeg-devel@ffmpeg.org Date: Mon, 10 Mar 2025 04:17:04 +0100 Message-ID: <20250310031713.76083-1-dev@lynne.ee> X-Mailer: git-send-email 2.47.2 MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH] [WIP] lavc: add an av1_vulkan encoder X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Lynne Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Archived-At: List-Archive: List-Post: This commit adds a Vulkan AV1 encoder, using the native acceleration API. This commit and patchset needs more testing, hence WIP for now. --- configure | 1 + libavcodec/Makefile | 2 + libavcodec/allcodecs.c | 1 + libavcodec/vulkan_encode_av1.c | 1381 ++++++++++++++++++++++++++++++++ libavcodec/vulkan_video.c | 82 ++ libavcodec/vulkan_video.h | 4 + libavutil/hwcontext_vulkan.c | 2 + libavutil/vulkan_functions.h | 1 + libavutil/vulkan_loader.h | 1 + 9 files changed, 1475 insertions(+) create mode 100644 libavcodec/vulkan_encode_av1.c diff --git a/configure b/configure index 04b83a8868..3465bb7734 100755 --- a/configure +++ b/configure @@ -3374,6 +3374,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 e3ccbf1838..42c030d721 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -271,6 +271,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 3be33f5cc4..57ee08c9ea 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..09ae320c3e --- /dev/null +++ b/libavcodec/vulkan_encode_av1.c @@ -0,0 +1,1381 @@ +/* + * 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; + } + } + + 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 = 3, + .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 183044b3ff..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,16 @@ 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) { @@ -268,6 +340,16 @@ int ff_vk_h265_profile_to_av(StdVideoH264ProfileIdc profile) } } +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 f791225e12..54b32bb76d 100644 --- a/libavcodec/vulkan_video.h +++ b/libavcodec/vulkan_video.h @@ -68,17 +68,21 @@ 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 */ 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); /** * Creates image views for video frames. diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c index 10521ce685..12f9ed215a 100644 --- a/libavutil/hwcontext_vulkan.c +++ b/libavutil/hwcontext_vulkan.c @@ -625,6 +625,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 }, }; @@ -1489,6 +1490,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 07c4546a3c..822f57a18b 100644 --- a/libavutil/vulkan_functions.h +++ b/libavutil/vulkan_functions.h @@ -59,6 +59,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 */ #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 3253863a62..21b3ded783 100644 --- a/libavutil/vulkan_loader.h +++ b/libavutil/vulkan_loader.h @@ -73,6 +73,7 @@ static inline uint64_t ff_vk_extensions_to_mask(const char * const *extensions, { VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME, FF_VK_EXT_VIDEO_DECODE_H265 }, { 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_VIDEO_ENCODE_AV1_EXTENSION_NAME, FF_VK_EXT_VIDEO_ENCODE_AV1 }, }; FFVulkanExtensions mask = 0x0; -- 2.47.2 _______________________________________________ ffmpeg-devel mailing list ffmpeg-devel@ffmpeg.org https://ffmpeg.org/mailman/listinfo/ffmpeg-devel To unsubscribe, visit link above, or email ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".