VK_KHR_video_decode_vp9

typedef struct VkVideoDecodeVP9ProfileInfoKHR {
    VkStructureType           sType;
    const void*               pNext;
    StdVideoVP9Profile        stdProfile;
} VkVideoDecodeVP9ProfileInfoKHR;

typedef struct VkVideoDecodeVP9CapabilitiesKHR {
    VkStructureType         sType;
    void*                   pNext;
    StdVideoVP9Level        maxLevel;
} VkVideoDecodeVP9CapabilitiesKHR;

typedef struct VkVideoDecodeVP9PictureInfoKHR {
    VkStructureType                     sType;
    const void*                         pNext;
    const StdVideoDecodeVP9PictureInfo* pStdPictureInfo;
    int32_t                             referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR];
    uint32_t                            uncompressedHeaderOffset;
    uint32_t                            compressedHeaderOffset;
    uint32_t                            tilesOffset;
} VkVideoDecodeVP9PictureInfoKHR;

uint32_t queueFamilyIndex;
uint32_t queueFamilyCount;

vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyCount, NULL);

VkQueueFamilyProperties2* props = calloc(queueFamilyCount,
    sizeof(VkQueueFamilyProperties2));
VkQueueFamilyVideoPropertiesKHR* videoProps = calloc(queueFamilyCount,
    sizeof(VkQueueFamilyVideoPropertiesKHR));

for (queueFamilyIndex = 0; queueFamilyIndex < queueFamilyCount; ++queueFamilyIndex) {
    props[queueFamilyIndex].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
    props[queueFamilyIndex].pNext = &videoProps[queueFamilyIndex];

    videoProps[queueFamilyIndex].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
}

vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyCount, props);

for (queueFamilyIndex = 0; queueFamilyIndex < queueFamilyCount; ++queueFamilyIndex) {
    if ((props[queueFamilyIndex].queueFamilyProperties.queueFlags & VK_QUEUE_VIDEO_DECODE_BIT_KHR) != 0 &&
        (videoProps[queueFamilyIndex].videoCodecOperations & VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) != 0) {
        break;
    }
}

if (queueFamilyIndex < queueFamilyCount) {
    // Found appropriate queue family
    ...
} else {
    // Did not find a queue family with the needed capabilities
    ...
}

VkResult result;

VkVideoDecodeVP9ProfileInfoKHR decodeVP9ProfileInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR,
    .pNext = NULL,
    .stdProfile = STD_VIDEO_VP9_PROFILE_0
};

VkVideoProfileInfoKHR profileInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
    .pNext = &decodeVP9ProfileInfo,
    .videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR,
    .chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
    .lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
    .chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR
};

VkVideoDecodeVP9CapabilitiesKHR decodeVP9Capabilities = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR,
    .pNext = NULL,
};

VkVideoDecodeCapabilitiesKHR decodeCapabilities = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR,
    .pNext = &decodeVP9Capabilities
}

VkVideoCapabilitiesKHR capabilities = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
    .pNext = &decodeCapabilities
};

result = vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &profileInfo, &capabilities);

if (result == VK_SUCCESS) {
    // Profile is supported, check additional capabilities
    ...
} else {
    // Profile is not supported, result provides additional information about why
    ...
}

vkCmdBeginVideoCodingKHR(commandBuffer, ...);

StdVideoDecodeVP9PictureInfo stdPictureInfo = {};
// parse and populate picture info from frame header data
...

VkVideoDecodeVP9PictureInfoKHR decodeVP9PictureInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR,
    .pNext = NULL,
    .pStdPictureInfo = &stdPictureInfo,
    .uncompressedHeaderOffset = ... // uncompressed header offset relative to the bitstream buffer range
    .compressedHeaderOffset = ... // compressed header offset relative to the bitstream buffer range
    .tilesOffset = ... // offset of tile data relative to the bitstream buffer range
};

// As no references are used, make sure that no DPB slot indices are associated with
// the VP9 reference names
for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
    decodeVP9PictureInfo.referenceNameSlotIndices[i] = -1;
}

VkVideoDecodeInfoKHR decodeInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
    .pNext = &decodeVP9PictureInfo,
    ...
    // reconstructed picture is not needed if video session was created without DPB slots
    .pSetupReferenceSlot = NULL,
    .referenceSlotCount = 0,
    .pReferenceSlots = NULL
};

vkCmdDecodeVideoKHR(commandBuffer, &decodeInfo);

vkCmdEndVideoCodingKHR(commandBuffer, ...);

vkCmdBeginVideoCodingKHR(commandBuffer, ...);

VkVideoReferenceSlotInfoKHR setupSlotInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
    .pNext = NULL, // VP9 decode does not need any std reference information
    ...
};

StdVideoDecodeVP9PictureInfo stdPictureInfo = {};
// parse and populate picture info from frame header data
...
if (stdPictureInfo.refresh_frame_flags != 0) {
    // reconstructed picture will activate DPB slot
} else {
    // reconstructed picture and slot may only be used by implementations as transient resource
}

VkVideoDecodeVP9PictureInfoKHR decodeVP9PictureInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR,
    .pNext = NULL,
    .pStdPictureInfo = &stdPictureInfo,
    .uncompressedHeaderOffset = ... // uncompressed header offset relative to the bitstream buffer range
    .compressedHeaderOffset = ... // compressed header offset relative to the bitstream buffer range
    .tilesOffset = ... // offset of tile data relative to the bitstream buffer range
};

// As no references are used, make sure that no DPB slot indices are associated with
// the VP9 reference names
for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
    decodeVP9PictureInfo.referenceNameSlotIndices[i] = -1;
}

VkVideoDecodeInfoKHR decodeInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
    .pNext = &decodeVP9PictureInfo,
    ...
    .pSetupReferenceSlot = &setupSlotInfo,
    ...
};

vkCmdDecodeVideoKHR(commandBuffer, &decodeInfo);

vkCmdEndVideoCodingKHR(commandBuffer, ...);

vkCmdBeginVideoCodingKHR(commandBuffer, ...);

VkVideoReferenceSlotInfoKHR referenceSlotInfo[] = {
    {
        .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
        .pNext = NULL, // VP9 decode does not need any std reference information
        ...
    },
    {
        .sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
        .pNext = NULL, // VP9 decode does not need any std reference information
        ...
    },
    ...
};

StdVideoDecodeVP9PictureInfo stdPictureInfo = {};
// parse and populate picture info from frame header data
...
if (stdPictureInfo.refresh_frame_flags != 0) {
    // reconstructed picture will activate DPB slot
} else {
    // reconstructed picture and slot may only be used as transient resource by implementations
}

VkVideoDecodeVP9PictureInfoKHR decodeVP9PictureInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR,
    .pNext = NULL,
    .pStdPictureInfo = &stdPictureInfo,
    .uncompressedHeaderOffset = ... // uncompressed header offset relative to the bitstream buffer range
    .compressedHeaderOffset = ... // compressed header offset relative to the bitstream buffer range
    .tilesOffset = ... // offset of tile data relative to the bitstream buffer range
};

// Initialize VP9 reference name to DPB slot index mapping and add mapping
// corresponding to the active reference picture list
for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
    decodeVP9PictureInfo.referenceNameSlotIndices[i] = -1;
}
// NOTE: This is just an example, the actually used VP9 reference names come from the frame header
decodeVP9PictureInfo.referenceNameSlotIndices[STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME - STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME] =
    referenceSlotInfo[0].slotIndex;
decodeVP9PictureInfo.referenceNameSlotIndices[STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME - STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME] =
    referenceSlotInfo[1].slotIndex;
...

VkVideoDecodeInfoKHR decodeInfo = {
    .sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
    .pNext = &decodeVP9PictureInfo,
    ...
    .referenceSlotCount = sizeof(referenceSlotInfo) / sizeof(referenceSlotInfo[0]),
    .pReferenceSlots = &referenceSlotInfo[0]
};

vkCmdDecodeVideoKHR(commandBuffer, &decodeInfo);

vkCmdEndVideoCodingKHR(commandBuffer, ...);