Skip to content

Vulkan Video VP9 decode support #59

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
dabrain34 merged 7 commits into from
Jun 16, 2025
Merged

Vulkan Video VP9 decode support #59

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
d3e8058
decode: Round up width/height of the luma plane
krajunv Mar 10, 2025
49e1374
decode: Remove assert when fence times out
krajunv Mar 18, 2025
5753d4b
common: Provide separate destructor implementation
krajunv Mar 18, 2025
48b501e
decode: Calculate chroma plane width separately
krajunv Apr 28, 2025
62fe670
common: Switch to VkSubmitInfo2KHR and use TL semaphores
zlatinski May 2, 2025
9f58f6b
decode: Add vp9 decoder support
krajunv Dec 30, 2024
321f336
decode: Include pSetupReferenceSlot in the VkVideoBeginCodingInfoKHR
krajunv Apr 28, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 10 additions & 0 deletions common/include/VkVideoCore/DecodeFrameBufferIf.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -107,6 +107,16 @@ class DecodeFrameBufferIf
}
};

enum SemSyncTypeIdx : uint64_t { SEM_SYNC_TYPE_IDX_DECODE = (1ULL << 0), // Decode operation was signaled
SEM_SYNC_TYPE_IDX_DISPLAY = (1ULL << 0), // Display operation was signaled
SEM_SYNC_TYPE_IDX_FILTER = (1ULL << 1), // Filter operation was signaled
SEM_SYNC_TYPE_IDX_SHIFT = 2, // Shift semaphore counter value left
};

static uint64_t GetSemaphoreValue(SemSyncTypeIdx semSyncType, uint64_t semOrder) {
return (semOrder << SEM_SYNC_TYPE_IDX_SHIFT) | semSyncType;
}

};

#endif /* _VKVIDEOCORE_DECODEFRAMEBUFFERIF_H_ */
45 changes: 41 additions & 4 deletions common/include/VkVideoCore/VkVideoCoreProfile.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,8 @@ class VkVideoCoreProfile
{
return (videoCodecOperations & (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR));
Expand Down Expand Up @@ -100,12 +101,26 @@ class VkVideoCoreProfile
m_av1DecodeProfile = *pProfileExt;
} else {
// Use default ext profile parameters
m_av1DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
m_av1DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
m_av1DecodeProfile.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN;
}
m_profile.pNext = &m_av1DecodeProfile;
m_av1DecodeProfile.pNext = NULL;

} else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
VkVideoDecodeVP9ProfileInfoKHR const * pProfileExt = (VkVideoDecodeVP9ProfileInfoKHR const *)pVideoProfileExt;
if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR)) {
m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
return false;
}
if (pProfileExt) {
m_vp9DecodeProfile = *pProfileExt;
} else {
// Use default ext profile parameters
m_vp9DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
m_vp9DecodeProfile.stdProfile = STD_VIDEO_VP9_PROFILE_0;
}
m_profile.pNext = &m_vp9DecodeProfile;
m_vp9DecodeProfile.pNext = NULL;
} else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) {
VkVideoEncodeH264ProfileInfoKHR const * pProfileExt = (VkVideoEncodeH264ProfileInfoKHR const *)pVideoProfileExt;
if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR)) {
Expand Down Expand Up @@ -205,6 +220,7 @@ class VkVideoCoreProfile
VkVideoDecodeH264ProfileInfoKHR decodeH264ProfilesRequest;
VkVideoDecodeH265ProfileInfoKHR decodeH265ProfilesRequest;
VkVideoDecodeAV1ProfileInfoKHR decodeAV1ProfilesRequest;
VkVideoDecodeVP9ProfileInfoKHR decodeVP9ProfilesRequest;
VkVideoEncodeH264ProfileInfoKHR encodeH264ProfilesRequest;
VkVideoEncodeH265ProfileInfoKHR encodeH265ProfilesRequest;
VkVideoEncodeAV1ProfileInfoKHR encodeAV1ProfilesRequest;
Expand Down Expand Up @@ -243,6 +259,13 @@ class VkVideoCoreProfile
STD_VIDEO_H265_PROFILE_IDC_INVALID :
(StdVideoH265ProfileIdc)videoH26xProfileIdc;
pVideoProfileExt = (VkBaseInStructure*)&decodeH265ProfilesRequest;
} else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
decodeVP9ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
decodeVP9ProfilesRequest.pNext = NULL;
decodeVP9ProfilesRequest.stdProfile = (videoH26xProfileIdc == 0) ?
STD_VIDEO_VP9_PROFILE_0 :
(StdVideoVP9Profile)videoH26xProfileIdc;
pVideoProfileExt = (VkBaseInStructure*)&decodeVP9ProfilesRequest;
} else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) {
encodeH264ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
encodeH264ProfilesRequest.pNext = pEncodeUsageInfo;
Expand Down Expand Up @@ -287,7 +310,9 @@ class VkVideoCoreProfile
bool IsDecodeCodecType() const
{
return ((m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) ||
(m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR));
(m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) ||
(m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) ||
(m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR));
}

operator bool() const
Expand Down Expand Up @@ -340,6 +365,15 @@ class VkVideoCoreProfile
}
}

const VkVideoDecodeVP9ProfileInfoKHR* GetDecodeVP9Profile() const
{
if (m_vp9DecodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR) {
return &m_vp9DecodeProfile;
} else {
return NULL;
}
}

const VkVideoEncodeH264ProfileInfoKHR* GetEncodeH264Profile() const
{
if (m_h264EncodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR) {
Expand Down Expand Up @@ -605,6 +639,8 @@ class VkVideoCoreProfile
return "decode h.265";
case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
return "decode av1";
case VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR:
return "decode vp9";
case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
return "encode h.264";
case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
Expand Down Expand Up @@ -769,6 +805,7 @@ class VkVideoCoreProfile
VkVideoDecodeH264ProfileInfoKHR m_h264DecodeProfile;
VkVideoDecodeH265ProfileInfoKHR m_h265DecodeProfile;
VkVideoDecodeAV1ProfileInfoKHR m_av1DecodeProfile;
VkVideoDecodeVP9ProfileInfoKHR m_vp9DecodeProfile;
VkVideoEncodeH264ProfileInfoKHR m_h264EncodeProfile;
VkVideoEncodeH265ProfileInfoKHR m_h265EncodeProfile;
VkVideoEncodeAV1ProfileInfoKHR m_av1EncodeProfile;
Expand Down
51 changes: 49 additions & 2 deletions common/include/VkVideoCore/VulkanVideoCapabilities.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,13 +38,16 @@ class VulkanVideoCapabilities
VkVideoDecodeH264CapabilitiesKHR h264Capabilities = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, nullptr };
VkVideoDecodeH265CapabilitiesKHR h265Capabilities = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, nullptr };
VkVideoDecodeAV1CapabilitiesKHR av1Capabilities = { VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, nullptr };
VkVideoDecodeVP9CapabilitiesKHR vp9Capabilities = { VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR, nullptr };

if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) {
videoDecodeCapabilities.pNext = &h264Capabilities;
} else if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) {
videoDecodeCapabilities.pNext = &h265Capabilities;
} else if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) {
videoDecodeCapabilities.pNext = &av1Capabilities;
} else if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
videoDecodeCapabilities.pNext = &vp9Capabilities;
} else {
assert(!"Unsupported codec");
return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
Expand Down Expand Up @@ -197,6 +200,16 @@ class VulkanVideoCapabilities
}
}
break;
case VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR:
{
assert(pVideoDecodeCapabilities->pNext);
const VkVideoDecodeVP9CapabilitiesKHR* pVP9Capabilities = (VkVideoDecodeVP9CapabilitiesKHR*)pVideoDecodeCapabilities->pNext;
assert(pVP9Capabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR);
if (pVP9Capabilities->sType != VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR) {
return VK_ERROR_INITIALIZATION_FAILED;
}
}
break;
case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
{
assert(pVideoEncodeCapabilities->pNext);
Expand Down Expand Up @@ -277,6 +290,26 @@ class VulkanVideoCapabilities
assert(!"Unsupported h.265 STD version");
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
} else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) {
const VkVideoDecodeAV1CapabilitiesKHR* pAV1DecCapabilities = (VkVideoDecodeAV1CapabilitiesKHR*)pVideoDecodeCapabilities->pNext;
std::cout << "\t\t\t" << "maxLevelIdc: " << pAV1DecCapabilities->maxLevel << std::endl;
if (strncmp(pVideoCapabilities->stdHeaderVersion.extensionName,
VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME,
sizeof (pVideoCapabilities->stdHeaderVersion.extensionName) - 1U) ||
(pVideoCapabilities->stdHeaderVersion.specVersion != VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION)) {
assert(!"Unsupported AV1 STD version");
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
} else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
const VkVideoDecodeVP9CapabilitiesKHR* pVP9DecCapabilities = (VkVideoDecodeVP9CapabilitiesKHR*)pVideoDecodeCapabilities->pNext;
std::cout << "\t\t\t" << "maxLevelIdc: " << pVP9DecCapabilities->maxLevel << std::endl;
if (strncmp(pVideoCapabilities->stdHeaderVersion.extensionName,
VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME,
sizeof (pVideoCapabilities->stdHeaderVersion.extensionName) - 1U) ||
(pVideoCapabilities->stdHeaderVersion.specVersion != VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION)) {
assert(!"Unsupported VP9 STD version");
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
} else {
assert(!"Unsupported codec");
}
Expand Down Expand Up @@ -354,8 +387,12 @@ class VulkanVideoCapabilities
int32_t* pVideoQueueFamily,
VkQueueFlags queueFlagsRequired = ( VK_QUEUE_VIDEO_DECODE_BIT_KHR | VK_QUEUE_VIDEO_ENCODE_BIT_KHR),
VkVideoCodecOperationFlagsKHR videoCodeOperations =
( VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR |
( VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR |
VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR))
{
std::vector<VkQueueFamilyProperties2> queues;
Expand Down Expand Up @@ -429,6 +466,16 @@ class VulkanVideoCapabilities
&videoDecodeCapabilities);
}

static VkResult GetDecodeVP9Capabilities(const VulkanDeviceContext* vkDevCtx, uint32_t,
const VkVideoProfileInfoKHR& videoProfile,
VkVideoCapabilitiesKHR &videoDecodeCapabilities)
{
videoDecodeCapabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
return vkDevCtx->GetPhysicalDeviceVideoCapabilitiesKHR(vkDevCtx->getPhysicalDevice(),
&videoProfile,
&videoDecodeCapabilities);
}

static VkResult GetEncodeH264Capabilities(const VulkanDeviceContext* vkDevCtx, uint32_t,
const VkVideoProfileInfoKHR& videoProfile,
VkVideoCapabilitiesKHR &videoEncodeCapabilities,
Expand Down
5 changes: 3 additions & 2 deletions common/libs/VkCodecUtils/DecoderConfig.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,7 +75,6 @@ struct DecoderConfig {
directMode = false;
enableHwLoadBalancing = false;
selectVideoWithComputeQueue = false;
enableVideoEncoder = false;
outputy4m = false;
outputcrcPerFrame = false;
outputcrc = false;
Expand Down Expand Up @@ -137,6 +136,9 @@ struct DecoderConfig {
} else if (strcmp(args[0], "av1") == 0) {
forceParserType = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
return true;
} else if ((strcmp(args[0], "vp9") == 0)) {
forceParserType = VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR;
return true;
} else {
std::cerr << "Invalid codec \"" << args[0] << "\"" << std::endl;
return false;
Expand Down Expand Up @@ -470,7 +472,6 @@ struct DecoderConfig {
uint32_t noPresent : 1;
uint32_t enableHwLoadBalancing : 1;
uint32_t selectVideoWithComputeQueue : 1;
uint32_t enableVideoEncoder : 1;
uint32_t outputy4m : 1;
uint32_t outputcrc : 1;
uint32_t outputcrcPerFrame : 1;
Expand Down
20 changes: 9 additions & 11 deletions common/libs/VkCodecUtils/Helpers.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -238,23 +238,21 @@ inline VkResult WaitAndResetFence(const VkInterfaceFunctions* vkIf, VkDevice dev

while (fenceTotalWaitTimeout >= fenceCurrentWaitTimeout) {

result = vkIf->WaitForFences(device, 1, &fence, true, fenceWaitTimeout);
if (result != VK_SUCCESS) {
fprintf(stderr, "\t **** WARNING: fence %s(%llu) is not done after %llu nSec with result 0x%x ****\n",
fenceName, (long long unsigned int)fence, (long long unsigned int)fenceWaitTimeout, result);
assert(!"Fence is not signaled yet after more than 100 mSec wait");
}
fenceCurrentWaitTimeout += fenceWaitTimeout;

if (result != VK_TIMEOUT) {
break;
result = vkIf->WaitForFences(device, 1, &fence, true, fenceWaitTimeout);
if (result == VK_TIMEOUT) {
fprintf(stderr, "\t **** WARNING: fence %s(%llu) is not done after %llu mSec with result 0x%x ****\n",
fenceName, (long long unsigned int)fence, (long long unsigned int)fenceCurrentWaitTimeout/(1000ULL * 1000ULL), result);
} else {
break; // either success or an error occured
}

fenceCurrentWaitTimeout += fenceWaitTimeout;
}

if (result != VK_SUCCESS) {
fprintf(stderr, "\t **** ERROR: fence %s(%llu) is not done after %llu nSec with result 0x%x ****\n",
fenceName, (long long unsigned int)fence, (long long unsigned int)fenceTotalWaitTimeout, vkIf->GetFenceStatus(device, fence));
fprintf(stderr, "\t **** ERROR: fence %s(%llu) is not done after %llu mSec with result 0x%x ****\n",
fenceName, (long long unsigned int)fence, (long long unsigned int)fenceTotalWaitTimeout/(1000ULL * 1000ULL), vkIf->GetFenceStatus(device, fence));
assert(!"Fence is not signaled yet after more than 100 mSec wait");
}

Expand Down
5 changes: 5 additions & 0 deletions common/libs/VkCodecUtils/VkImageResource.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -88,6 +88,11 @@ VkImageResource::VkImageResource(const VulkanDeviceContext* vkDevCtx,
}
}

VkImageResource::~VkImageResource()
{
Destroy();
}

VkResult VkImageResource::Create(const VulkanDeviceContext* vkDevCtx,
const VkImageCreateInfo* pImageCreateInfo,
VkMemoryPropertyFlags memoryPropertyFlags,
Expand Down
2 changes: 1 addition & 1 deletion common/libs/VkCodecUtils/VkImageResource.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -113,7 +113,7 @@ class VkImageResource : public VkVideoRefCountBase

void Destroy();

virtual ~VkImageResource() { Destroy(); }
virtual ~VkImageResource();
};

class VkImageResourceView : public VkVideoRefCountBase
Expand Down
18 changes: 8 additions & 10 deletions common/libs/VkCodecUtils/VkVideoFrameToFile.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -328,15 +328,19 @@ class VkVideoFrameToFileImpl : public VkVideoFrameOutput {
const uint8_t* readImagePtr = srcImageDeviceMemory->GetReadOnlyDataPtr(imageOffset, maxSize);
assert(readImagePtr != nullptr);

int32_t secondaryPlaneWidth = frameWidth;
int32_t secondaryPlaneHeight = frameHeight;
int32_t imageHeight = frameHeight;
bool isUnnormalizedRgba = false;
if (mpInfo && (mpInfo->planesLayout.layout == YCBCR_SINGLE_PLANE_UNNORMALIZED) && !(mpInfo->planesLayout.disjoint)) {
isUnnormalizedRgba = true;
}

if (mpInfo && mpInfo->planesLayout.secondaryPlaneSubsampledX) {
secondaryPlaneWidth = (secondaryPlaneWidth + 1) / 2;
}
if (mpInfo && mpInfo->planesLayout.secondaryPlaneSubsampledY) {
secondaryPlaneHeight /= 2;
secondaryPlaneHeight = (secondaryPlaneHeight + 1) / 2;
}

VkImageSubresource subResource = {};
Expand Down Expand Up @@ -381,15 +385,9 @@ class VkVideoFrameToFileImpl : public VkVideoFrameOutput {
yuvPlaneLayouts[0].offset = 0;
yuvPlaneLayouts[0].rowPitch = frameWidth * bytesPerPixel;
yuvPlaneLayouts[1].offset = yuvPlaneLayouts[0].rowPitch * frameHeight;
yuvPlaneLayouts[1].rowPitch = frameWidth * bytesPerPixel;
if (mpInfo && mpInfo->planesLayout.secondaryPlaneSubsampledX) {
yuvPlaneLayouts[1].rowPitch /= 2;
}
yuvPlaneLayouts[1].rowPitch = secondaryPlaneWidth * bytesPerPixel;
yuvPlaneLayouts[2].offset = yuvPlaneLayouts[1].offset + (yuvPlaneLayouts[1].rowPitch * secondaryPlaneHeight);
yuvPlaneLayouts[2].rowPitch = frameWidth * bytesPerPixel;
if (mpInfo && mpInfo->planesLayout.secondaryPlaneSubsampledX) {
yuvPlaneLayouts[2].rowPitch /= 2;
}
yuvPlaneLayouts[2].rowPitch = secondaryPlaneWidth * bytesPerPixel;

// Copy the luma plane
const uint32_t numCompatiblePlanes = 1;
Expand All @@ -410,7 +408,7 @@ class VkVideoFrameToFileImpl : public VkVideoFrameOutput {
for (uint32_t plane = numCompatiblePlanes; plane < numPlanes; plane++) {
const uint32_t srcPlane = std::min(plane, mpInfo->planesLayout.numberOfExtraPlanes);
uint8_t* pDst = pOutBuffer + yuvPlaneLayouts[plane].offset;
const int32_t planeWidth = mpInfo->planesLayout.secondaryPlaneSubsampledX ? frameWidth / 2 : frameWidth;
const int32_t planeWidth = mpInfo->planesLayout.secondaryPlaneSubsampledX ? (frameWidth + 1) / 2 : frameWidth;

for (int32_t height = 0; height < secondaryPlaneHeight; height++) {
const uint8_t* pSrc;
Expand Down
Loading