decoder: Fix bitstream buffer alignment for all codecs

Fix srcBufferOffset and srcBufferRange alignment to satisfy Vulkan spec
requirements for vkCmdDecodeVideoKHR (VUID-07131, VUID-07139).

Problem
-------
The parser's bitstreamDataOffset and bitstreamDataLen values were passed
directly into VkVideoDecodeInfoKHR without any alignment, causing
validation errors on H.264, H.265, and AV1 (VP9 already handled this).

Parser Buffer Architecture
--------------------------
The NvVideoParser manages bitstream buffers as follows:

1. Buffers are allocated via GetBitstreamBuffer() with size rounded up
   to minBitstreamBufferSizeAlignment (typically 256 bytes).

2. The parser fills the buffer with compressed frame data sequentially.
   When a frame boundary is detected (end_of_picture), the parser
   reports bitstreamDataOffset (where frame data starts in the buffer)
   and bitstreamDataLen (exact byte count of the frame's NAL units).

3. The buffer often contains BOTH the current frame's data AND the
   beginning of the next frame's data (residual). After the decode
   command is submitted, swapBitstreamBuffer() copies this residual
   data to a new aligned buffer for the next frame.

4. For H.264/H.265 (NAL-based codecs via VulkanVideoDecoder::
   end_of_picture), bitstreamDataOffset is always 0 -- the frame data
   starts at the buffer beginning.

5. For VP9, the parser explicitly handles alignment in
   VulkanVP9Decoder::ParseFrameHeader (line 251-261): offset is
   aligned down, internal offsets are adjusted, and bitstreamDataLen
   is aligned up -- all at the parser level.

6. For AV1, bitstreamDataOffset is 0 (set in VulkanAV1Decoder::
   end_of_picture).

srcBufferOffset Fix
-------------------
For H.264/H.265/AV1: Assert that bitstreamDataOffset is 0 (enforced
by the parser architecture). Force to 0 as a safety net if violated.

For VP9: Trust the parser's alignment (already correct).

srcBufferRange Fix (per-codec)
------------------------------
H.265, AV1, VP9: Round up bitstreamDataLen to minBitstreamBufferSizeAlignment.
  These codecs use explicit slice segment offsets (pSliceSegmentOffsets)
  or tile sizes (pTileSizes) for decode boundaries. NVDEC ignores bytes
  beyond the last slice/tile, so the residual data in the alignment
  padding area is harmless.

H.264: Pass exact bitstreamDataLen WITHOUT rounding up.
  NVDEC's H.264 decoder uses srcBufferRange to bound its start-code
  scan (searching for 00 00 01 patterns). The buffer's residual area
  beyond bitstreamDataLen contains the next frame's data, which starts
  with a valid start code. Rounding up exposes this start code to the
  NAL scanner, causing decode corruption. Suppress VUID-07139 for H.264.
  The proper fix requires handling alignment in the H.264 parser
  (like VP9 does), but that is a larger change to NvVideoParser's
  ByteStreamParser buffer management.

IMPORTANT: The bytes beyond bitstreamDataLen must NOT be zero-filled.
  They contain the next frame's residual data that swapBitstreamBuffer()
  copies after the decode returns. Zero-filling destroys this data and
  corrupts all subsequent frames.

Also fix VulkanBitstreamBufferImpl::GetSizeAlignment() which incorrectly
returned VkMemoryRequirements::alignment instead of m_bufferSizeAlignment
(the minBitstreamBufferSizeAlignment from VkVideoCapabilitiesKHR).

Fixes: VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07131 (srcBufferOffset)
Fixes: VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07139 (srcBufferRange, H.265/AV1/VP9)
Suppresses: VUID-07139 for H.264 (requires parser-level fix)
Ref: KhronosGroup/Vulkan-ValidationLayers#11531
Ref: #183
Signed-off-by: Tony Zlatinski <tzlatinski@nvidia.com>

Author: zlatinski

common/libs/VkCodecUtils/VulkanBistreamBufferImpl.cpp

@@ -222,7 +222,7 @@ VkDeviceSize VulkanBitstreamBufferImpl::GetOffsetAlignment() const
 
 VkDeviceSize VulkanBitstreamBufferImpl::GetSizeAlignment() const
 {
-    return m_vulkanDeviceMemory->GetMemoryRequirements().alignment;
+    return m_bufferSizeAlignment;
 }
 
 VkDeviceSize VulkanBitstreamBufferImpl::Resize(VkDeviceSize newSize, VkDeviceSize copySize, VkDeviceSize copyOffset)

common/libs/VkCodecUtils/VulkanDeviceContext.cpp

@@ -447,6 +447,15 @@ static constexpr uint32_t g_ignoredValidationMessageIds[] = {
     // at all when there's no usage override. TODO: fix in VkImageResource.cpp.
     0x1f778da5,
 
+    // VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07139 (MessageID = 0xe9634196)
+    // H.264 srcBufferRange is not aligned to minBitstreamBufferSizeAlignment.
+    // NVDEC's H.264 NAL scanner uses srcBufferRange to bound its start-code scan.
+    // Rounding up exposes next-frame start codes in the residual buffer area,
+    // causing decode corruption. H.265/AV1/VP9 are properly aligned.
+    // The proper fix is to handle alignment in the H.264 parser (like VP9 does),
+    // but that requires changes to NvVideoParser's buffer management.
+    0xe9634196,
+
     // VUID-vkGetImageSubresourceLayout-tiling-08717 (MessageID = 0x4148a5e9)
     // vkGetImageSubresourceLayout called with VK_IMAGE_ASPECT_COLOR_BIT on
     // multi-planar NV12 images. Should use VK_IMAGE_ASPECT_PLANE_0_BIT /

vk_video_decoder/libs/VkVideoDecoder/VkVideoDecoder.cpp

@@ -757,12 +757,57 @@ int VkVideoDecoder::DecodePictureWithParameters(VkParserPerFrameDecodeParameters
     assert(pCurrFrameDecParams->bitstreamData->GetMaxSize() >= pCurrFrameDecParams->bitstreamDataLen);
 
     pCurrFrameDecParams->decodeFrameInfo.srcBuffer = pCurrFrameDecParams->bitstreamData->GetBuffer();
-    //assert(pCurrFrameDecParams->bitstreamDataOffset == 0);
     assert(pCurrFrameDecParams->firstSliceIndex == 0);
-    // TODO: Assert if bitstreamDataOffset is aligned to VkVideoCapabilitiesKHR::minBitstreamBufferOffsetAlignment
-    pCurrFrameDecParams->decodeFrameInfo.srcBufferOffset = pCurrFrameDecParams->bitstreamDataOffset;
-    // TODO: Assert if bitstreamDataLen is aligned to VkVideoCapabilitiesKHR::minBitstreamBufferSizeAlignment
-    pCurrFrameDecParams->decodeFrameInfo.srcBufferRange =  pCurrFrameDecParams->bitstreamDataLen;
+
+    // Verify bitstream buffer alignment invariants.
+    // The parser's buffer management (swapBitstreamBuffer / GetBitstreamBuffer) ensures:
+    //   - Buffers are allocated with size rounded up to minBitstreamBufferSizeAlignment
+    //   - Residual data is copied to offset 0 of a new aligned buffer
+    //   - bitstreamDataOffset is 0 for H.264/H.265/AV1 (set in end_of_picture)
+    //   - VP9 aligns offset in the parser (VulkanVP9Decoder.cpp:261)
+    const VkDeviceSize offsetAlignment = pCurrFrameDecParams->bitstreamData->GetOffsetAlignment();
+    const VkDeviceSize sizeAlignment   = pCurrFrameDecParams->bitstreamData->GetSizeAlignment();
+    const VkDeviceSize bufferMaxSize   = pCurrFrameDecParams->bitstreamData->GetMaxSize();
+
+    // srcBufferOffset: must be 0 (H.264/H.265/AV1) or aligned (VP9).
+    // These codecs don't use non-zero offsets in the parser's end_of_picture.
+    VkDeviceSize srcOffset = pCurrFrameDecParams->bitstreamDataOffset;
+    assert((srcOffset & (offsetAlignment - 1)) == 0 &&
+           "bitstreamDataOffset must be aligned to minBitstreamBufferOffsetAlignment");
+    // Safety: force to 0 for codecs that should not have non-zero offset
+    if (m_videoFormat.codec != VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
+        if (srcOffset != 0) {
+            fprintf(stderr, "WARNING: bitstreamDataOffset=%zu is non-zero for non-VP9 codec, forcing to 0\n",
+                    (size_t)srcOffset);
+            srcOffset = 0;
+        }
+    }
+
+    // srcBufferRange alignment to minBitstreamBufferSizeAlignment.
+    // The bytes beyond bitstreamDataLen contain the next frame's residual data
+    // (swapBitstreamBuffer copies it after decode returns), so we cannot zero-fill.
+    //
+    // H.264: NVDEC's NAL scanner uses srcBufferRange to bound its start-code scan.
+    //   Rounding up exposes the next frame's start codes in the residual area,
+    //   causing decode corruption. Pass exact bitstreamDataLen for H.264.
+    // H.265/AV1: Use slice segment offsets / tile sizes exclusively, so rounding
+    //   up is safe -- the residual data is ignored by the HW decoder.
+    // VP9: Already aligned by the parser (VulkanVP9Decoder.cpp:259).
+    VkDeviceSize srcRange = pCurrFrameDecParams->bitstreamDataLen;
+    bool canAlignRange = (m_videoFormat.codec != VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR);
+    VkDeviceSize alignedRange;
+    if (canAlignRange) {
+        alignedRange = (srcRange + (sizeAlignment - 1)) & ~(sizeAlignment - 1);
+        if (srcOffset + alignedRange > bufferMaxSize) {
+            alignedRange = bufferMaxSize - srcOffset;
+        }
+    } else {
+        // H.264: pass exact range; suppress VUID-07139 in g_ignoredValidationMessageIds
+        alignedRange = srcRange;
+    }
+
+    pCurrFrameDecParams->decodeFrameInfo.srcBufferOffset = srcOffset;
+    pCurrFrameDecParams->decodeFrameInfo.srcBufferRange  = alignedRange;
 
     VkVideoBeginCodingInfoKHR decodeBeginInfo = { VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR };
     decodeBeginInfo.pNext = pCurrFrameDecParams->beginCodingInfoPictureParametersExt;