1 files changed, 55 insertions, 0 deletions
diff --git a/src/yuv_buffer.cc b/src/yuv_buffer.cc
index c74e140..efb8016 100644
--- a/src/yuv_buffer.cc
+++ b/src/yuv_buffer.cc
@@ -20,6 +20,7 @@
 
 #include "src/frame_buffer_utils.h"
 #include "src/utils/common.h"
+#include "src/utils/compiler_attributes.h"
 #include "src/utils/logging.h"
 
 namespace libgav1 {
@@ -195,6 +196,60 @@ bool YuvBuffer::Realloc(int bitdepth, bool is_monochrome, int width, int height,
   assert(!is_monochrome || buffer_[kPlaneU] == nullptr);
   assert(!is_monochrome || buffer_[kPlaneV] == nullptr);
 
+#if LIBGAV1_MSAN
+  const int pixel_size = (bitdepth == 8) ? sizeof(uint8_t) : sizeof(uint16_t);
+  int width_in_bytes = width * pixel_size;
+  // The optimized loop restoration code will overread the visible frame buffer
+  // into the right border. The optimized cfl subsambler uses the right border
+  // as well. Initialize the right border and padding to prevent msan warnings.
+  int right_border_size_in_bytes = right_border * pixel_size;
+  // Calculate the padding bytes for the buffer. Note: The stride of the buffer
+  // is always a multiple of 16. (see yuv_buffer.h)
+  const int right_padding_in_bytes =
+      stride_[kPlaneY] - (pixel_size * (width + left_border + right_border));
+  const int padded_right_border_size =
+      right_border_size_in_bytes + right_padding_in_bytes;
+  constexpr uint8_t right_val = 0x55;
+  uint8_t* rb = buffer_[kPlaneY] + width_in_bytes;
+  for (int i = 0; i < height + bottom_border; ++i) {
+    memset(rb, right_val, padded_right_border_size);
+    rb += stride_[kPlaneY];
+  }
+  if (!is_monochrome) {
+    int uv_width_in_bytes = uv_width * pixel_size;
+    int uv_right_border_size_in_bytes = uv_right_border * pixel_size;
+    const int u_right_padding_in_bytes =
+        stride_[kPlaneU] -
+        (pixel_size * (uv_width + uv_left_border + uv_right_border));
+    const int u_padded_right_border_size =
+        uv_right_border_size_in_bytes + u_right_padding_in_bytes;
+    rb = buffer_[kPlaneU] + uv_width_in_bytes;
+    for (int i = 0; i < uv_height; ++i) {
+      memset(rb, right_val, u_padded_right_border_size);
+      rb += stride_[kPlaneU];
+    }
+    const int v_right_padding_in_bytes =
+        stride_[kPlaneV] -
+        ((uv_width + uv_left_border + uv_right_border) * pixel_size);
+    const int v_padded_right_border_size =
+        uv_right_border_size_in_bytes + v_right_padding_in_bytes;
+    rb = buffer_[kPlaneV] + uv_width_in_bytes;
+    for (int i = 0; i < uv_height; ++i) {
+      memset(rb, right_val, v_padded_right_border_size);
+      rb += stride_[kPlaneV];
+    }
+  }
+
+  // The optimized cfl subsampler will overread (to the right of the current
+  // block) into the uninitialized visible area. The cfl subsampler can overread
+  // into the bottom border as well. Initialize the both to quiet msan warnings.
+  uint8_t* y_visible = buffer_[kPlaneY];
+  for (int i = 0; i < height + bottom_border; ++i) {
+    memset(y_visible, right_val, width_in_bytes);
+    y_visible += stride_[kPlaneY];
+  }
+#endif
+
   return true;
 }