Common: Add alignment header

Gets rid of duplicated alignment code.

18 files changed, 72 insertions, 68 deletions

diff --git a/Source/Core/VideoBackends/D3D/D3DUtil.cpp b/Source/Core/VideoBackends/D3D/D3DUtil.cpp
index 639b1988c0..6e73bea9a8 100644
--- a/Source/Core/VideoBackends/D3D/D3DUtil.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DUtil.cpp
@@ -6,6 +6,7 @@
 #include <list>
 #include <string>
 
+#include "Common/Align.h"
 #include "VideoBackends/D3D/D3DBase.h"
 #include "VideoBackends/D3D/D3DShader.h"
 #include "VideoBackends/D3D/D3DState.h"
@@ -22,7 +23,7 @@ namespace D3D
 class UtilVertexBuffer
 {
 public:
-  UtilVertexBuffer(int size) : buf(nullptr), offset(0), max_size(size)
+  UtilVertexBuffer(unsigned int size) : max_size(size)
   {
     D3D11_BUFFER_DESC desc = CD3D11_BUFFER_DESC(max_size, D3D11_BIND_VERTEX_BUFFER,
                                                 D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
@@ -31,7 +32,7 @@ public:
   ~UtilVertexBuffer() { buf->Release(); }
   int GetSize() const { return max_size; }
   // returns vertex offset to the new data
-  int AppendData(void* data, int size, int vertex_size)
+  int AppendData(void* data, unsigned int size, unsigned int vertex_size)
   {
     D3D11_MAPPED_SUBRESOURCE map;
     if (offset + size >= max_size)
@@ -47,8 +48,7 @@ public:
     {
       context->Map(buf, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &map);
     }
-    offset = ((offset + vertex_size - 1) / vertex_size) *
-             vertex_size;  // align offset to vertex_size bytes
+    offset = Common::AlignUp(offset, vertex_size);
     memcpy((u8*)map.pData + offset, data, size);
     context->Unmap(buf, 0);
 
@@ -56,13 +56,12 @@ public:
     return (offset - size) / vertex_size;
   }
 
-  int BeginAppendData(void** write_ptr, int size, int vertex_size)
+  int BeginAppendData(void** write_ptr, unsigned int size, unsigned int vertex_size)
   {
     _dbg_assert_(VIDEO, size < max_size);
 
     D3D11_MAPPED_SUBRESOURCE map;
-    int aligned_offset = ((offset + vertex_size - 1) / vertex_size) *
-                         vertex_size;  // align offset to vertex_size bytes
+    unsigned int aligned_offset = Common::AlignUp(offset, vertex_size);
     if (aligned_offset + size > max_size)
     {
       // wrap buffer around and notify observers
@@ -87,9 +86,9 @@ public:
   void AddWrapObserver(bool* observer) { observers.push_back(observer); }
   inline ID3D11Buffer*& GetBuffer() { return buf; }
 private:
-  ID3D11Buffer* buf;
-  int offset;
-  int max_size;
+  ID3D11Buffer* buf = nullptr;
+  unsigned int offset = 0;
+  unsigned int max_size;
 
   std::list<bool*> observers;
 };
diff --git a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
index 85b84eaf0d..1d8cef5fd9 100644
--- a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include "Common/Align.h"
 #include "Common/FileUtil.h"
 #include "Common/LinearDiskCache.h"
 #include "Common/StringUtil.h"
@@ -135,7 +136,8 @@ const char copy_shader_code[] = {
 
 void GeometryShaderCache::Init()
 {
-  unsigned int gbsize = ROUND_UP(sizeof(GeometryShaderConstants), 16);  // must be a multiple of 16
+  unsigned int gbsize = Common::AlignUp(static_cast<unsigned int>(sizeof(GeometryShaderConstants)),
+                                        16);  // must be a multiple of 16
   D3D11_BUFFER_DESC gbdesc = CD3D11_BUFFER_DESC(gbsize, D3D11_BIND_CONSTANT_BUFFER,
                                                 D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
   HRESULT hr = D3D::device->CreateBuffer(&gbdesc, nullptr, &gscbuf);
diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
index df65d562e0..5364c58cdd 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/LinearDiskCache.h"
@@ -457,7 +458,8 @@ public:
 
 void PixelShaderCache::Init()
 {
-  unsigned int cbsize = ROUND_UP(sizeof(PixelShaderConstants), 16);  // must be a multiple of 16
+  unsigned int cbsize = Common::AlignUp(static_cast<unsigned int>(sizeof(PixelShaderConstants)),
+                                        16);  // must be a multiple of 16
   D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER,
                                                 D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
   D3D::device->CreateBuffer(&cbdesc, nullptr, &pscbuf);
diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
index 02b027f2ba..a698ed6ebd 100644
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/LinearDiskCache.h"
@@ -122,7 +123,8 @@ void VertexShaderCache::Init()
       {"COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
   };
 
-  unsigned int cbsize = ROUND_UP(sizeof(VertexShaderConstants), 16);  // must be a multiple of 16
+  unsigned int cbsize = Common::AlignUp(static_cast<unsigned int>(sizeof(VertexShaderConstants)),
+                                        16);  // must be a multiple of 16
   D3D11_BUFFER_DESC cbdesc = CD3D11_BUFFER_DESC(cbsize, D3D11_BIND_CONSTANT_BUFFER,
                                                 D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
   HRESULT hr = D3D::device->CreateBuffer(&cbdesc, nullptr, &vscbuf);
diff --git a/Source/Core/VideoBackends/D3D12/D3DTexture.cpp b/Source/Core/VideoBackends/D3D12/D3DTexture.cpp
index 1d8146f1e6..20b0eb5b39 100644
--- a/Source/Core/VideoBackends/D3D12/D3DTexture.cpp
+++ b/Source/Core/VideoBackends/D3D12/D3DTexture.cpp
@@ -4,6 +4,7 @@
 
 #include <memory>
 
+#include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/MsgHandler.h"
 #include "VideoBackends/D3D12/D3DBase.h"
@@ -34,7 +35,7 @@ void ReplaceRGBATexture2D(ID3D12Resource* texture12, const u8* buffer, unsigned
                           D3D12_RESOURCE_STATES current_resource_state)
 {
   const unsigned int upload_size =
-      AlignValue(src_pitch, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * height;
+      Common::AlignUp(src_pitch, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * height;
 
   ID3D12Resource* upload_buffer = nullptr;
   size_t upload_buffer_offset = 0;
diff --git a/Source/Core/VideoBackends/D3D12/D3DUtil.cpp b/Source/Core/VideoBackends/D3D12/D3DUtil.cpp
index 61e39d376a..4b7e4767c3 100644
--- a/Source/Core/VideoBackends/D3D12/D3DUtil.cpp
+++ b/Source/Core/VideoBackends/D3D12/D3DUtil.cpp
@@ -7,6 +7,8 @@
 #include <memory>
 #include <string>
 
+#include "Common/Align.h"
+
 #include "VideoBackends/D3D12/D3DBase.h"
 #include "VideoBackends/D3D12/D3DCommandListManager.h"
 #include "VideoBackends/D3D12/D3DDescriptorHeapManager.h"
@@ -254,8 +256,9 @@ int CD3DFont::Init()
   ID3D12Resource* temporaryFontTextureUploadBuffer;
   CheckHR(D3D::device12->CreateCommittedResource(
       &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE,
-      &CD3DX12_RESOURCE_DESC::Buffer(
-          AlignValue(m_tex_width * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * m_tex_height),
+      &CD3DX12_RESOURCE_DESC::Buffer(Common::AlignUp(static_cast<unsigned int>(m_tex_width) * 4,
+                                                     D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
+                                     m_tex_height),
       D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&temporaryFontTextureUploadBuffer)));
 
   D3D12_SUBRESOURCE_DATA subresource_data_dest = {
diff --git a/Source/Core/VideoBackends/D3D12/D3DUtil.h b/Source/Core/VideoBackends/D3D12/D3DUtil.h
index 942f9bcdec..9b3794cc05 100644
--- a/Source/Core/VideoBackends/D3D12/D3DUtil.h
+++ b/Source/Core/VideoBackends/D3D12/D3DUtil.h
@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 
-#include "Common/MathUtil.h"
 #include "VideoBackends/D3D12/D3DState.h"
 #include "VideoBackends/D3D12/D3DStreamBuffer.h"
 
@@ -19,11 +18,6 @@ extern StateCache gx_state_cache;
 
 namespace D3D
 {
-constexpr unsigned int AlignValue(unsigned int value, unsigned int alignment)
-{
-  return (value + (alignment - 1)) & ~(alignment - 1);
-}
-
 void ResourceBarrier(ID3D12GraphicsCommandList* command_list, ID3D12Resource* resource,
                      D3D12_RESOURCE_STATES state_before, D3D12_RESOURCE_STATES state_after,
                      UINT subresource);
diff --git a/Source/Core/VideoBackends/D3D12/FramebufferManager.cpp b/Source/Core/VideoBackends/D3D12/FramebufferManager.cpp
index f567852568..77b2a411ae 100644
--- a/Source/Core/VideoBackends/D3D12/FramebufferManager.cpp
+++ b/Source/Core/VideoBackends/D3D12/FramebufferManager.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "VideoBackends/D3D12/FramebufferManager.h"
+#include "Common/Align.h"
 #include "Core/HW/Memmap.h"
 #include "VideoBackends/D3D12/D3DBase.h"
 #include "VideoBackends/D3D12/D3DCommandListManager.h"
@@ -324,8 +325,8 @@ void FramebufferManager::InitializeEFBAccessCopies()
   buf12->Release();
 
   // EFB access - color staging/readback buffer
-  m_efb.color_access_readback_pitch =
-      D3D::AlignValue(EFB_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+  m_efb.color_access_readback_pitch = Common::AlignUp(static_cast<u32>(EFB_WIDTH * sizeof(u32)),
+                                                      D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
   texdesc12 = CD3DX12_RESOURCE_DESC::Buffer(m_efb.color_access_readback_pitch * EFB_HEIGHT);
   hr = D3D::device12->CreateCommittedResource(
       &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &texdesc12,
@@ -347,8 +348,8 @@ void FramebufferManager::InitializeEFBAccessCopies()
   buf12->Release();
 
   // EFB access - depth staging/readback buffer
-  m_efb.depth_access_readback_pitch =
-      D3D::AlignValue(EFB_WIDTH * sizeof(float), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+  m_efb.depth_access_readback_pitch = Common::AlignUp(static_cast<u32>(EFB_WIDTH * sizeof(float)),
+                                                      D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
   texdesc12 = CD3DX12_RESOURCE_DESC::Buffer(m_efb.depth_access_readback_pitch * EFB_HEIGHT);
   hr = D3D::device12->CreateCommittedResource(
       &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &texdesc12,
diff --git a/Source/Core/VideoBackends/D3D12/PSTextureEncoder.cpp b/Source/Core/VideoBackends/D3D12/PSTextureEncoder.cpp
index 25c5dd92c5..f95c1528eb 100644
--- a/Source/Core/VideoBackends/D3D12/PSTextureEncoder.cpp
+++ b/Source/Core/VideoBackends/D3D12/PSTextureEncoder.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "VideoBackends/D3D12/PSTextureEncoder.h"
+#include "Common/Align.h"
 #include "Core/HW/Memmap.h"
 #include "VideoBackends/D3D12/D3DBase.h"
 #include "VideoBackends/D3D12/D3DCommandListManager.h"
@@ -62,7 +63,7 @@ void PSTextureEncoder::Init()
   CheckHR(D3D::device12->CreateCommittedResource(
       &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE,
       &CD3DX12_RESOURCE_DESC::Buffer(
-          D3D::AlignValue(static_cast<unsigned int>(out_tex_desc.Width) * 4,
+          Common::AlignUp(static_cast<unsigned int>(out_tex_desc.Width) * 4,
                           D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
           out_tex_desc.Height),
       D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_out_readback_buffer)));
@@ -179,7 +180,7 @@ void PSTextureEncoder::Encode(u8* dst, u32 format, u32 native_width, u32 bytes_p
   dst_location.PlacedFootprint.Footprint.Width = EFB_WIDTH * 4;
   dst_location.PlacedFootprint.Footprint.Height = EFB_HEIGHT / 4;
   dst_location.PlacedFootprint.Footprint.Depth = 1;
-  dst_location.PlacedFootprint.Footprint.RowPitch = D3D::AlignValue(
+  dst_location.PlacedFootprint.Footprint.RowPitch = Common::AlignUp(
       dst_location.PlacedFootprint.Footprint.Width * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
 
   D3D12_TEXTURE_COPY_LOCATION src_location = {};
diff --git a/Source/Core/VideoBackends/D3D12/Render.cpp b/Source/Core/VideoBackends/D3D12/Render.cpp
index 2bfe8d3a07..be65d04f4b 100644
--- a/Source/Core/VideoBackends/D3D12/Render.cpp
+++ b/Source/Core/VideoBackends/D3D12/Render.cpp
@@ -9,6 +9,7 @@
 #include <strsafe.h>
 #include <unordered_map>
 
+#include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/MathUtil.h"
@@ -180,7 +181,7 @@ void CreateScreenshotTexture()
   // This texture is released to be recreated when the window is resized in Renderer::SwapImpl.
 
   const unsigned int screenshot_buffer_size =
-      D3D::AlignValue(D3D::GetBackBufferWidth() * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
+      Common::AlignUp(D3D::GetBackBufferWidth() * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
       D3D::GetBackBufferHeight();
 
   CheckHR(D3D::device12->CreateCommittedResource(
@@ -757,7 +758,7 @@ void Renderer::SwapImpl(u32 xfb_addr, u32 fb_width, u32 fb_stride, u32 fb_height
     dst_location.PlacedFootprint.Footprint.Width = GetTargetRectangle().GetWidth();
     dst_location.PlacedFootprint.Footprint.Height = GetTargetRectangle().GetHeight();
     dst_location.PlacedFootprint.Footprint.Depth = 1;
-    dst_location.PlacedFootprint.Footprint.RowPitch = D3D::AlignValue(
+    dst_location.PlacedFootprint.Footprint.RowPitch = Common::AlignUp(
         dst_location.PlacedFootprint.Footprint.Width * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
 
     D3D12_TEXTURE_COPY_LOCATION src_location = {};
diff --git a/Source/Core/VideoBackends/D3D12/TextureCache.cpp b/Source/Core/VideoBackends/D3D12/TextureCache.cpp
index ffedeeeadc..322cec9b1d 100644
--- a/Source/Core/VideoBackends/D3D12/TextureCache.cpp
+++ b/Source/Core/VideoBackends/D3D12/TextureCache.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "VideoBackends/D3D12/TextureCache.h"
+#include "Common/Align.h"
 #include "VideoBackends/D3D12/D3DBase.h"
 #include "VideoBackends/D3D12/D3DCommandListManager.h"
 #include "VideoBackends/D3D12/D3DDescriptorHeapManager.h"
@@ -44,7 +45,7 @@ bool TextureCache::TCacheEntry::Save(const std::string& filename, unsigned int l
   u32 level_width = std::max(config.width >> level, 1u);
   u32 level_height = std::max(config.height >> level, 1u);
   size_t level_pitch =
-      D3D::AlignValue(level_width * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+      Common::AlignUp(level_width * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
   size_t required_readback_buffer_size = level_pitch * level_height;
 
   // Check if the current readback buffer is large enough
diff --git a/Source/Core/VideoBackends/D3D12/XFBEncoder.cpp b/Source/Core/VideoBackends/D3D12/XFBEncoder.cpp
index a2b2bc1998..9e0d15327e 100644
--- a/Source/Core/VideoBackends/D3D12/XFBEncoder.cpp
+++ b/Source/Core/VideoBackends/D3D12/XFBEncoder.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "VideoBackends/D3D12/XFBEncoder.h"
+#include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 #include "Common/MsgHandler.h"
@@ -23,7 +24,7 @@ constexpr size_t XFB_TEXTURE_HEIGHT = MAX_XFB_HEIGHT;
 
 // Buffer enough space for 2 XFB buffers (our frame latency)
 constexpr size_t XFB_UPLOAD_BUFFER_SIZE =
-    D3D::AlignValue(XFB_TEXTURE_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
+    Common::AlignUp(XFB_TEXTURE_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
     XFB_TEXTURE_HEIGHT * 2;
 constexpr size_t XFB_ENCODER_PARAMS_BUFFER_SIZE = 64 * 1024;
 
@@ -48,7 +49,7 @@ XFBEncoder::XFBEncoder()
   CheckHR(D3D::device12->CreateCommittedResource(
       &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE,
       &CD3DX12_RESOURCE_DESC::Buffer(
-          D3D::AlignValue(XFB_TEXTURE_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
+          Common::AlignUp(XFB_TEXTURE_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
           MAX_XFB_HEIGHT),
       D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_readback_buffer)));
 
@@ -117,7 +118,8 @@ void XFBEncoder::EncodeTextureToRam(u8* dst, u32 dst_pitch, u32 dst_height,
 
   // Copy from YUYV intermediate texture to readback buffer. It's likely the pitch here is going to
   // be different to dst_pitch.
-  u32 readback_pitch = D3D::AlignValue(dst_width * sizeof(u16), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+  u32 readback_pitch = static_cast<u32>(
+      Common::AlignUp(dst_width * sizeof(u16), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT));
   D3D12_PLACED_SUBRESOURCE_FOOTPRINT dst_footprint = {
       0, {DXGI_FORMAT_R8G8B8A8_UNORM, dst_texture_width, dst_height, 1, readback_pitch}};
   CD3DX12_TEXTURE_COPY_LOCATION dst_location(m_readback_buffer, dst_footprint);
@@ -154,8 +156,8 @@ void XFBEncoder::DecodeToTexture(D3DTexture2D* dst_texture, const u8* src, u32 s
                "XFB source does not exceed maximum size");
 
   // Copy to XFB upload buffer. Each row has to be done separately due to pitch differences.
-  u32 buffer_pitch =
-      D3D::AlignValue(src_width / 2 * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+  u32 buffer_pitch = static_cast<u32>(
+      Common::AlignUp(src_width / 2 * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT));
   m_upload_buffer->AllocateSpaceInBuffer(buffer_pitch * src_height,
                                          D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
   for (u32 row = 0; row < src_height; row++)
diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
index 66952ed976..44bf063a8a 100644
--- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
+++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
@@ -5,8 +5,8 @@
 #include <memory>
 #include <string>
 
+#include "Common/Align.h"
 #include "Common/Common.h"
-#include "Common/MathUtil.h"
 #include "Common/StringUtil.h"
 
 #include "Core/ConfigManager.h"
@@ -148,22 +148,22 @@ void ProgramShaderCache::UploadConstants()
 
     memcpy(buffer.first, &PixelShaderManager::constants, sizeof(PixelShaderConstants));
 
-    memcpy(buffer.first + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align),
+    memcpy(buffer.first + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align),
            &VertexShaderManager::constants, sizeof(VertexShaderConstants));
 
-    memcpy(buffer.first + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align) +
-               ROUND_UP(sizeof(VertexShaderConstants), s_ubo_align),
+    memcpy(buffer.first + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align) +
+               Common::AlignUp(sizeof(VertexShaderConstants), s_ubo_align),
            &GeometryShaderManager::constants, sizeof(GeometryShaderConstants));
 
     s_buffer->Unmap(s_ubo_buffer_size);
     glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->m_buffer, buffer.second,
                       sizeof(PixelShaderConstants));
     glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->m_buffer,
-                      buffer.second + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align),
+                      buffer.second + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align),
                       sizeof(VertexShaderConstants));
     glBindBufferRange(GL_UNIFORM_BUFFER, 3, s_buffer->m_buffer,
-                      buffer.second + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align) +
-                          ROUND_UP(sizeof(VertexShaderConstants), s_ubo_align),
+                      buffer.second + Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align) +
+                          Common::AlignUp(sizeof(VertexShaderConstants), s_ubo_align),
                       sizeof(GeometryShaderConstants));
 
     PixelShaderManager::dirty = false;
@@ -407,9 +407,10 @@ void ProgramShaderCache::Init()
   // then the UBO will fail.
   glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &s_ubo_align);
 
-  s_ubo_buffer_size = ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align) +
-                      ROUND_UP(sizeof(VertexShaderConstants), s_ubo_align) +
-                      ROUND_UP(sizeof(GeometryShaderConstants), s_ubo_align);
+  s_ubo_buffer_size =
+      static_cast<u32>(Common::AlignUp(sizeof(PixelShaderConstants), s_ubo_align) +
+                       Common::AlignUp(sizeof(VertexShaderConstants), s_ubo_align) +
+                       Common::AlignUp(sizeof(GeometryShaderConstants), s_ubo_align));
 
   // We multiply by *4*4 because we need to get down to basic machine units.
   // So multiply by four to get how many floats we have from vec4s
diff --git a/Source/Core/VideoBackends/OGL/StreamBuffer.cpp b/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
index a81d96b0ff..97a25a5bc7 100644
--- a/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
+++ b/Source/Core/VideoBackends/OGL/StreamBuffer.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include "Common/Align.h"
 #include "Common/GL/GLUtil.h"
 #include "Common/MemoryUtil.h"
 
@@ -261,11 +262,11 @@ public:
   PinnedMemory(u32 type, u32 size) : StreamBuffer(type, size)
   {
     CreateFences();
-    m_pointer = static_cast<u8*>(
-        Common::AllocateAlignedMemory(ROUND_UP(m_size, ALIGN_PINNED_MEMORY), ALIGN_PINNED_MEMORY));
+    m_pointer = static_cast<u8*>(Common::AllocateAlignedMemory(
+        Common::AlignUp(m_size, ALIGN_PINNED_MEMORY), ALIGN_PINNED_MEMORY));
     glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_buffer);
-    glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, ROUND_UP(m_size, ALIGN_PINNED_MEMORY),
-                 m_pointer, GL_STREAM_COPY);
+    glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD,
+                 Common::AlignUp(m_size, ALIGN_PINNED_MEMORY), m_pointer, GL_STREAM_COPY);
     glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0);
     glBindBuffer(m_buffertype, m_buffer);
   }
diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp
index 15e159b30f..dcb29de2a5 100644
--- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp
+++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include "Common/Align.h"
 #include "Common/CommonFuncs.h"
 #include "Common/CommonTypes.h"
 #include "Common/MsgHandler.h"
@@ -215,7 +216,7 @@ static void SetSpans(int sBlkSize, int tBlkSize, s32* tSpan, s32* sBlkSpan, s32*
 {
   // width is 1 less than the number of pixels of width
   u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale;
-  u32 alignedWidth = (width + sBlkSize) & (~(sBlkSize - 1));
+  u32 alignedWidth = Common::AlignUp(width, sBlkSize);
 
   u32 readStride = 3 << bpmem.triggerEFBCopy.half_scale;
 
diff --git a/Source/Core/VideoBackends/Vulkan/StateTracker.cpp b/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
index 34ea98f41b..e9bbb980b0 100644
--- a/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
+++ b/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
@@ -6,6 +6,7 @@
 
 #include <cstring>
 
+#include "Common/Align.h"
 #include "Common/Assert.h"
 
 #include "VideoBackends/Vulkan/CommandBufferManager.h"
@@ -101,11 +102,11 @@ bool StateTracker::Initialize()
   // To work around this we reserve the maximum buffer size at all times, but only commit
   // as many bytes as we use.
   m_uniform_buffer_reserve_size = sizeof(PixelShaderConstants);
-  m_uniform_buffer_reserve_size = Util::AlignValue(m_uniform_buffer_reserve_size,
-                                                   g_vulkan_context->GetUniformBufferAlignment()) +
+  m_uniform_buffer_reserve_size = Common::AlignUp(m_uniform_buffer_reserve_size,
+                                                  g_vulkan_context->GetUniformBufferAlignment()) +
                                   sizeof(VertexShaderConstants);
-  m_uniform_buffer_reserve_size = Util::AlignValue(m_uniform_buffer_reserve_size,
-                                                   g_vulkan_context->GetUniformBufferAlignment()) +
+  m_uniform_buffer_reserve_size = Common::AlignUp(m_uniform_buffer_reserve_size,
+                                                  g_vulkan_context->GetUniformBufferAlignment()) +
                                   sizeof(GeometryShaderConstants);
 
   // Default dirty flags include all descriptors
@@ -461,9 +462,9 @@ void StateTracker::UploadAllConstants()
   size_t ub_alignment = g_vulkan_context->GetUniformBufferAlignment();
   size_t pixel_constants_offset = 0;
   size_t vertex_constants_offset =
-      Util::AlignValue(pixel_constants_offset + sizeof(PixelShaderConstants), ub_alignment);
+      Common::AlignUp(pixel_constants_offset + sizeof(PixelShaderConstants), ub_alignment);
   size_t geometry_constants_offset =
-      Util::AlignValue(vertex_constants_offset + sizeof(VertexShaderConstants), ub_alignment);
+      Common::AlignUp(vertex_constants_offset + sizeof(VertexShaderConstants), ub_alignment);
   size_t allocation_size = geometry_constants_offset + sizeof(GeometryShaderConstants);
 
   // Allocate everything at once.
diff --git a/Source/Core/VideoBackends/Vulkan/Util.cpp b/Source/Core/VideoBackends/Vulkan/Util.cpp
index f85321bac5..f49ca90580 100644
--- a/Source/Core/VideoBackends/Vulkan/Util.cpp
+++ b/Source/Core/VideoBackends/Vulkan/Util.cpp
@@ -4,6 +4,7 @@
 
 #include "VideoBackends/Vulkan/Util.h"
 
+#include "Common/Align.h"
 #include "Common/Assert.h"
 #include "Common/CommonFuncs.h"
 #include "Common/MathUtil.h"
@@ -20,22 +21,13 @@ namespace Vulkan
 {
 namespace Util
 {
-size_t AlignValue(size_t value, size_t alignment)
-{
-  // Have to use mod rather than masking bits in case alignment is not a power of two.
-  size_t offset = value % alignment;
-  if (offset != 0)
-    value += (alignment - offset);
-  return value;
-}
-
 size_t AlignBufferOffset(size_t offset, size_t alignment)
 {
   // Assume an offset of zero is already aligned to a value larger than alignment.
   if (offset == 0)
     return 0;
 
-  return AlignValue(offset, alignment);
+  return Common::AlignUp(offset, alignment);
 }
 
 u32 MakeRGBA8Color(float r, float g, float b, float a)
diff --git a/Source/Core/VideoBackends/Vulkan/Util.h b/Source/Core/VideoBackends/Vulkan/Util.h
index bb701716c2..7ee8e82356 100644
--- a/Source/Core/VideoBackends/Vulkan/Util.h
+++ b/Source/Core/VideoBackends/Vulkan/Util.h
@@ -19,7 +19,6 @@ class StateTracker;
 
 namespace Util
 {
-size_t AlignValue(size_t value, size_t alignment);
 size_t AlignBufferOffset(size_t offset, size_t alignment);
 
 u32 MakeRGBA8Color(float r, float g, float b, float a);