diff --git a/Source/Core/Core/HW/DVD/DVDInterface.cpp b/Source/Core/Core/HW/DVD/DVDInterface.cpp
index 66ea9a0eb4..dd9a2c0ccf 100644
--- a/Source/Core/Core/HW/DVD/DVDInterface.cpp
+++ b/Source/Core/Core/HW/DVD/DVDInterface.cpp
@@ -36,6 +36,7 @@
 #include "Core/Movie.h"
 
 #include "DiscIO/Blob.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/VolumeDisc.h"
 #include "DiscIO/VolumeWii.h"
@@ -164,6 +165,7 @@ static u8 s_dtk_buffer_length = 0;  // TODO: figure out how this affects the reg
 // Disc drive state
 static DriveState s_drive_state;
 static DriveError s_error_code;
+static u64 s_disc_end_offset;
 
 // Disc drive timing
 static u64 s_read_buffer_start_time;
@@ -425,6 +427,33 @@ void Shutdown()
   DVDThread::Stop();
 }
 
+static u64 GetDiscEndOffset(const DiscIO::VolumeDisc& disc)
+{
+  u64 size = disc.GetSize();
+
+  if (disc.IsSizeAccurate())
+  {
+    if (size == DiscIO::MINI_DVD_SIZE)
+      return DiscIO::MINI_DVD_SIZE;
+  }
+  else
+  {
+    size = DiscIO::GetBiggestReferencedOffset(disc);
+  }
+
+  const bool should_be_mini_dvd =
+      disc.GetVolumeType() == DiscIO::Platform::GameCubeDisc || disc.IsDatelDisc();
+
+  // We always return standard DVD sizes here, not DVD-R sizes.
+  // RVT-R (devkit) consoles can't read the extra megabytes there are on RVT-R (DVD-R) discs.
+  if (should_be_mini_dvd && size <= DiscIO::MINI_DVD_SIZE)
+    return DiscIO::MINI_DVD_SIZE;
+  else if (size <= DiscIO::SL_DVD_R_SIZE)
+    return DiscIO::SL_DVD_SIZE;
+  else
+    return DiscIO::DL_DVD_SIZE;
+}
+
 void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
              std::optional<std::vector<std::string>> auto_disc_change_paths = {})
 {
@@ -433,6 +462,10 @@ void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
 
   if (has_disc)
   {
+    s_disc_end_offset = GetDiscEndOffset(*disc);
+    if (!disc->IsSizeAccurate())
+      WARN_LOG_FMT(DVDINTERFACE, "Unknown disc size, guessing {0} bytes", s_disc_end_offset);
+
     const DiscIO::BlobReader& blob = disc->GetBlobReader();
     if (!blob.HasFastRandomAccessInBlock() && blob.GetBlockSize() > 0x200000)
     {
@@ -763,20 +796,11 @@ static bool ExecuteReadCommand(u64 dvd_offset, u32 output_address, u32 dvd_lengt
     dvd_length = output_length;
   }
 
-  // Many Wii games intentionally try to read from an offset which is just past the end of a regular
-  // DVD but just before the end of a DVD-R, displaying "Error #001" and failing to boot if the read
-  // succeeds (see https://wiibrew.org/wiki//dev/di#0x8D_DVDLowUnencryptedRead for more details).
-  // It would be nice if we simply could rely on DiscIO for letting us know whether a read is out
-  // of bounds, but this unfortunately doesn't work when using a disc image format that doesn't
-  // store the original size of the disc, most notably WBFS. Instead, we have a little hack here:
-  // reject all non-partition reads that come from IOS that go past the offset 0x50000. IOS only
-  // allows non-partition reads if they are before 0x50000 or if they are in one of the two small
-  // areas 0x118240000-0x118240020 and 0x1FB4E0000-0x1FB4E0020 (both of which only are used for
-  // Error #001 checks), so the only thing we disallow with this hack that actually should be
-  // allowed is non-partition reads in the 0x118240000-0x118240020 area on dual-layer discs.
-  // In practice, dual-layer games don't attempt to do non-partition reads in that area.
-  if (reply_type == ReplyType::IOS && partition == DiscIO::PARTITION_NONE &&
-      dvd_offset + dvd_length > 0x50000)
+  // Many Wii games intentionally try to read from an offset which is just past the end of a
+  // regular DVD but just before the end of a DVD-R, displaying "Error #001" and failing to boot
+  // if the read succeeds, so it's critical that we set the correct error code for such reads.
+  // See https://wiibrew.org/wiki//dev/di#0x8D_DVDLowUnencryptedRead for details on Error #001.
+  if (dvd_offset + dvd_length > s_disc_end_offset)
   {
     SetDriveError(DriveError::BlockOOB);
     *interrupt_type = DIInterruptType::DEINT;
diff --git a/Source/Core/Core/HW/DVD/DVDThread.cpp b/Source/Core/Core/HW/DVD/DVDThread.cpp
index 1cd143269b..bd79cc05fe 100644
--- a/Source/Core/Core/HW/DVD/DVDThread.cpp
+++ b/Source/Core/Core/HW/DVD/DVDThread.cpp
@@ -347,7 +347,7 @@ static void FinishRead(u64 id, s64 cycles_late)
     PanicAlertFmtT("The disc could not be read (at {0:#x} - {1:#x}).", request.dvd_offset,
                    request.dvd_offset + request.length);
 
-    DVDInterface::SetDriveError(DVDInterface::DriveError::BlockOOB);
+    DVDInterface::SetDriveError(DVDInterface::DriveError::ReadError);
     interrupt = DVDInterface::DIInterruptType::DEINT;
   }
   else
diff --git a/Source/Core/DiscIO/CMakeLists.txt b/Source/Core/DiscIO/CMakeLists.txt
index 54e437c521..1729f0d959 100644
--- a/Source/Core/DiscIO/CMakeLists.txt
+++ b/Source/Core/DiscIO/CMakeLists.txt
@@ -11,6 +11,8 @@ add_library(discio
   DiscExtractor.h
   DiscScrubber.cpp
   DiscScrubber.h
+  DiscUtils.cpp
+  DiscUtils.h
   DriveBlob.cpp
   DriveBlob.h
   Enums.cpp
diff --git a/Source/Core/DiscIO/DirectoryBlob.cpp b/Source/Core/DiscIO/DirectoryBlob.cpp
index 8840283777..65451a33d1 100644
--- a/Source/Core/DiscIO/DirectoryBlob.cpp
+++ b/Source/Core/DiscIO/DirectoryBlob.cpp
@@ -28,6 +28,7 @@
 #include "Core/Boot/DolReader.h"
 #include "Core/IOS/ES/Formats.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/VolumeWii.h"
 #include "DiscIO/WiiEncryptionCache.h"
 
@@ -653,8 +654,8 @@ void DirectoryBlobPartition::SetDiscHeaderAndDiscType(std::optional<bool> is_wii
   }
   else
   {
-    m_is_wii = Common::swap32(&m_disc_header[0x18]) == 0x5d1c9ea3;
-    const bool is_gc = Common::swap32(&m_disc_header[0x1c]) == 0xc2339f3d;
+    m_is_wii = Common::swap32(&m_disc_header[0x18]) == WII_DISC_MAGIC;
+    const bool is_gc = Common::swap32(&m_disc_header[0x1c]) == GAMECUBE_DISC_MAGIC;
     if (m_is_wii == is_gc)
       ERROR_LOG_FMT(DISCIO, "Couldn't detect disc type based on {}", boot_bin_path);
   }
diff --git a/Source/Core/DiscIO/DiscExtractor.cpp b/Source/Core/DiscIO/DiscExtractor.cpp
index 8aff525cec..5cc665f7d9 100644
--- a/Source/Core/DiscIO/DiscExtractor.cpp
+++ b/Source/Core/DiscIO/DiscExtractor.cpp
@@ -5,50 +5,21 @@
 #include "DiscIO/DiscExtractor.h"
 
 #include <algorithm>
-#include <locale>
+#include <functional>
 #include <optional>
-
-#include <fmt/format.h>
+#include <string>
+#include <string_view>
 
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
 #include "Common/IOFile.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
 
 namespace DiscIO
 {
-std::string NameForPartitionType(u32 partition_type, bool include_prefix)
-{
-  switch (partition_type)
-  {
-  case PARTITION_DATA:
-    return "DATA";
-  case PARTITION_UPDATE:
-    return "UPDATE";
-  case PARTITION_CHANNEL:
-    return "CHANNEL";
-  case PARTITION_INSTALL:
-    // wit doesn't recognize the name "INSTALL", so we can't use it when naming partition folders
-    if (!include_prefix)
-      return "INSTALL";
-    [[fallthrough]];
-  default:
-    const std::string type_as_game_id{static_cast<char>((partition_type >> 24) & 0xFF),
-                                      static_cast<char>((partition_type >> 16) & 0xFF),
-                                      static_cast<char>((partition_type >> 8) & 0xFF),
-                                      static_cast<char>(partition_type & 0xFF)};
-    if (std::all_of(type_as_game_id.cbegin(), type_as_game_id.cend(),
-                    [](char c) { return std::isalnum(c, std::locale::classic()); }))
-    {
-      return include_prefix ? "P-" + type_as_game_id : type_as_game_id;
-    }
-
-    return fmt::format(include_prefix ? "P{}" : "{}", partition_type);
-  }
-}
-
 u64 ReadFile(const Volume& volume, const Partition& partition, const FileInfo* file_info,
              u8* buffer, u64 max_buffer_size, u64 offset_in_file)
 {
@@ -248,17 +219,6 @@ bool ExportBI2Data(const Volume& volume, const Partition& partition,
   return ExportData(volume, partition, 0x440, 0x2000, export_filename);
 }
 
-std::optional<u64> GetApploaderSize(const Volume& volume, const Partition& partition)
-{
-  constexpr u64 header_size = 0x20;
-  const std::optional<u32> apploader_size = volume.ReadSwapped<u32>(0x2440 + 0x14, partition);
-  const std::optional<u32> trailer_size = volume.ReadSwapped<u32>(0x2440 + 0x18, partition);
-  if (!apploader_size || !trailer_size)
-    return std::nullopt;
-
-  return header_size + *apploader_size + *trailer_size;
-}
-
 bool ExportApploader(const Volume& volume, const Partition& partition,
                      const std::string& export_filename)
 {
@@ -272,51 +232,6 @@ bool ExportApploader(const Volume& volume, const Partition& partition,
   return ExportData(volume, partition, 0x2440, *apploader_size, export_filename);
 }
 
-std::optional<u64> GetBootDOLOffset(const Volume& volume, const Partition& partition)
-{
-  const Platform volume_type = volume.GetVolumeType();
-  if (!IsDisc(volume_type))
-    return std::nullopt;
-
-  std::optional<u64> dol_offset = volume.ReadSwappedAndShifted(0x420, partition);
-
-  // Datel AR disc has 0x00000000 as the offset (invalid) and doesn't use it in the AppLoader.
-  if (dol_offset && *dol_offset == 0)
-    dol_offset.reset();
-
-  return dol_offset;
-}
-
-std::optional<u32> GetBootDOLSize(const Volume& volume, const Partition& partition, u64 dol_offset)
-{
-  if (!IsDisc(volume.GetVolumeType()))
-    return std::nullopt;
-
-  u32 dol_size = 0;
-
-  // Iterate through the 7 code segments
-  for (u8 i = 0; i < 7; i++)
-  {
-    const std::optional<u32> offset = volume.ReadSwapped<u32>(dol_offset + 0x00 + i * 4, partition);
-    const std::optional<u32> size = volume.ReadSwapped<u32>(dol_offset + 0x90 + i * 4, partition);
-    if (!offset || !size)
-      return {};
-    dol_size = std::max(*offset + *size, dol_size);
-  }
-
-  // Iterate through the 11 data segments
-  for (u8 i = 0; i < 11; i++)
-  {
-    const std::optional<u32> offset = volume.ReadSwapped<u32>(dol_offset + 0x1c + i * 4, partition);
-    const std::optional<u32> size = volume.ReadSwapped<u32>(dol_offset + 0xac + i * 4, partition);
-    if (!offset || !size)
-      return {};
-    dol_size = std::max(*offset + *size, dol_size);
-  }
-
-  return dol_size;
-}
-
 bool ExportDOL(const Volume& volume, const Partition& partition, const std::string& export_filename)
 {
   if (!IsDisc(volume.GetVolumeType()))
@@ -332,24 +247,6 @@ bool ExportDOL(const Volume& volume, const Partition& partition, const std::stri
   return ExportData(volume, partition, *dol_offset, *dol_size, export_filename);
 }
 
-std::optional<u64> GetFSTOffset(const Volume& volume, const Partition& partition)
-{
-  const Platform volume_type = volume.GetVolumeType();
-  if (!IsDisc(volume_type))
-    return std::nullopt;
-
-  return volume.ReadSwappedAndShifted(0x424, partition);
-}
-
-std::optional<u64> GetFSTSize(const Volume& volume, const Partition& partition)
-{
-  const Platform volume_type = volume.GetVolumeType();
-  if (!IsDisc(volume_type))
-    return std::nullopt;
-
-  return volume.ReadSwappedAndShifted(0x428, partition);
-}
-
 bool ExportFST(const Volume& volume, const Partition& partition, const std::string& export_filename)
 {
   if (!IsDisc(volume.GetVolumeType()))
diff --git a/Source/Core/DiscIO/DiscExtractor.h b/Source/Core/DiscIO/DiscExtractor.h
index c7e18f83d6..07ca88adf6 100644
--- a/Source/Core/DiscIO/DiscExtractor.h
+++ b/Source/Core/DiscIO/DiscExtractor.h
@@ -17,13 +17,6 @@ class FileInfo;
 struct Partition;
 class Volume;
 
-constexpr u32 PARTITION_DATA = 0;
-constexpr u32 PARTITION_UPDATE = 1;
-constexpr u32 PARTITION_CHANNEL = 2;  // Mario Kart Wii, Wii Fit, Wii Fit Plus, Rabbids Go Home
-constexpr u32 PARTITION_INSTALL = 3;  // Dragon Quest X only
-
-std::string NameForPartitionType(u32 partition_type, bool include_prefix);
-
 u64 ReadFile(const Volume& volume, const Partition& partition, const FileInfo* file_info,
              u8* buffer, u64 max_buffer_size, u64 offset_in_file = 0);
 u64 ReadFile(const Volume& volume, const Partition& partition, std::string_view path, u8* buffer,
@@ -61,15 +54,10 @@ bool ExportHeader(const Volume& volume, const Partition& partition,
                   const std::string& export_filename);
 bool ExportBI2Data(const Volume& volume, const Partition& partition,
                    const std::string& export_filename);
-std::optional<u64> GetApploaderSize(const Volume& volume, const Partition& partition);
 bool ExportApploader(const Volume& volume, const Partition& partition,
                      const std::string& export_filename);
-std::optional<u64> GetBootDOLOffset(const Volume& volume, const Partition& partition);
-std::optional<u32> GetBootDOLSize(const Volume& volume, const Partition& partition, u64 dol_offset);
 bool ExportDOL(const Volume& volume, const Partition& partition,
                const std::string& export_filename);
-std::optional<u64> GetFSTOffset(const Volume& volume, const Partition& partition);
-std::optional<u64> GetFSTSize(const Volume& volume, const Partition& partition);
 bool ExportFST(const Volume& volume, const Partition& partition,
                const std::string& export_filename);
 
diff --git a/Source/Core/DiscIO/DiscScrubber.cpp b/Source/Core/DiscIO/DiscScrubber.cpp
index bd39e8bb7a..7ed42f870a 100644
--- a/Source/Core/DiscIO/DiscScrubber.cpp
+++ b/Source/Core/DiscIO/DiscScrubber.cpp
@@ -16,7 +16,7 @@
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 
-#include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
 
diff --git a/Source/Core/DiscIO/DiscUtils.cpp b/Source/Core/DiscIO/DiscUtils.cpp
new file mode 100644
index 0000000000..d0bcd66857
--- /dev/null
+++ b/Source/Core/DiscIO/DiscUtils.cpp
@@ -0,0 +1,202 @@
+// Copyright 2021 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "DiscIO/DiscUtils.h"
+
+#include <algorithm>
+#include <locale>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "Common/CommonTypes.h"
+#include "DiscIO/Filesystem.h"
+#include "DiscIO/Volume.h"
+
+namespace DiscIO
+{
+std::string NameForPartitionType(u32 partition_type, bool include_prefix)
+{
+  switch (partition_type)
+  {
+  case PARTITION_DATA:
+    return "DATA";
+  case PARTITION_UPDATE:
+    return "UPDATE";
+  case PARTITION_CHANNEL:
+    return "CHANNEL";
+  case PARTITION_INSTALL:
+    // wit doesn't recognize the name "INSTALL", so we can't use it when naming partition folders
+    if (!include_prefix)
+      return "INSTALL";
+    [[fallthrough]];
+  default:
+    const std::string type_as_game_id{static_cast<char>((partition_type >> 24) & 0xFF),
+                                      static_cast<char>((partition_type >> 16) & 0xFF),
+                                      static_cast<char>((partition_type >> 8) & 0xFF),
+                                      static_cast<char>(partition_type & 0xFF)};
+    if (std::all_of(type_as_game_id.cbegin(), type_as_game_id.cend(),
+                    [](char c) { return std::isalnum(c, std::locale::classic()); }))
+    {
+      return include_prefix ? "P-" + type_as_game_id : type_as_game_id;
+    }
+
+    return fmt::format(include_prefix ? "P{}" : "{}", partition_type);
+  }
+}
+
+std::optional<u64> GetApploaderSize(const Volume& volume, const Partition& partition)
+{
+  constexpr u64 header_size = 0x20;
+  const std::optional<u32> apploader_size = volume.ReadSwapped<u32>(0x2440 + 0x14, partition);
+  const std::optional<u32> trailer_size = volume.ReadSwapped<u32>(0x2440 + 0x18, partition);
+  if (!apploader_size || !trailer_size)
+    return std::nullopt;
+
+  return header_size + *apploader_size + *trailer_size;
+}
+
+std::optional<u64> GetBootDOLOffset(const Volume& volume, const Partition& partition)
+{
+  const Platform volume_type = volume.GetVolumeType();
+  if (!IsDisc(volume_type))
+    return std::nullopt;
+
+  std::optional<u64> dol_offset = volume.ReadSwappedAndShifted(0x420, partition);
+
+  // Datel AR disc has 0x00000000 as the offset (invalid) and doesn't use it in the AppLoader.
+  if (dol_offset && *dol_offset == 0)
+    dol_offset.reset();
+
+  return dol_offset;
+}
+
+std::optional<u32> GetBootDOLSize(const Volume& volume, const Partition& partition, u64 dol_offset)
+{
+  if (!IsDisc(volume.GetVolumeType()))
+    return std::nullopt;
+
+  u32 dol_size = 0;
+
+  // Iterate through the 7 code segments
+  for (size_t i = 0; i < 7; i++)
+  {
+    const std::optional<u32> offset = volume.ReadSwapped<u32>(dol_offset + 0x00 + i * 4, partition);
+    const std::optional<u32> size = volume.ReadSwapped<u32>(dol_offset + 0x90 + i * 4, partition);
+    if (!offset || !size)
+      return {};
+    dol_size = std::max(*offset + *size, dol_size);
+  }
+
+  // Iterate through the 11 data segments
+  for (size_t i = 0; i < 11; i++)
+  {
+    const std::optional<u32> offset = volume.ReadSwapped<u32>(dol_offset + 0x1c + i * 4, partition);
+    const std::optional<u32> size = volume.ReadSwapped<u32>(dol_offset + 0xac + i * 4, partition);
+    if (!offset || !size)
+      return {};
+    dol_size = std::max(*offset + *size, dol_size);
+  }
+
+  return dol_size;
+}
+
+std::optional<u64> GetFSTOffset(const Volume& volume, const Partition& partition)
+{
+  const Platform volume_type = volume.GetVolumeType();
+  if (!IsDisc(volume_type))
+    return std::nullopt;
+
+  return volume.ReadSwappedAndShifted(0x424, partition);
+}
+
+std::optional<u64> GetFSTSize(const Volume& volume, const Partition& partition)
+{
+  const Platform volume_type = volume.GetVolumeType();
+  if (!IsDisc(volume_type))
+    return std::nullopt;
+
+  return volume.ReadSwappedAndShifted(0x428, partition);
+}
+
+u64 GetBiggestReferencedOffset(const Volume& volume)
+{
+  std::vector<Partition> partitions = volume.GetPartitions();
+
+  // If a partition doesn't seem to contain any valid data, skip it.
+  // This can happen when certain programs that create WBFS files scrub the entirety of
+  // the Masterpiece partitions in Super Smash Bros. Brawl without removing them from
+  // the partition table. https://bugs.dolphin-emu.org/issues/8733
+  const auto it =
+      std::remove_if(partitions.begin(), partitions.end(), [&](const Partition& partition) {
+        return volume.ReadSwapped<u32>(0x18, partition) != WII_DISC_MAGIC;
+      });
+  partitions.erase(it, partitions.end());
+
+  if (partitions.empty())
+    partitions.push_back(PARTITION_NONE);
+
+  return GetBiggestReferencedOffset(volume, partitions);
+}
+
+static u64 GetBiggestReferencedOffset(const Volume& volume, const FileInfo& file_info)
+{
+  if (file_info.IsDirectory())
+  {
+    u64 biggest_offset = 0;
+    for (const FileInfo& f : file_info)
+      biggest_offset = std::max(biggest_offset, GetBiggestReferencedOffset(volume, f));
+    return biggest_offset;
+  }
+  else
+  {
+    return file_info.GetOffset() + file_info.GetSize();
+  }
+}
+
+u64 GetBiggestReferencedOffset(const Volume& volume, const std::vector<Partition>& partitions)
+{
+  const u64 disc_header_size = volume.GetVolumeType() == Platform::GameCubeDisc ? 0x460 : 0x50000;
+  u64 biggest_offset = disc_header_size;
+  for (const Partition& partition : partitions)
+  {
+    if (partition != PARTITION_NONE)
+    {
+      const u64 offset = volume.PartitionOffsetToRawOffset(0x440, partition);
+      biggest_offset = std::max(biggest_offset, offset);
+    }
+
+    const std::optional<u64> dol_offset = GetBootDOLOffset(volume, partition);
+    if (dol_offset)
+    {
+      const std::optional<u64> dol_size = GetBootDOLSize(volume, partition, *dol_offset);
+      if (dol_size)
+      {
+        const u64 offset = volume.PartitionOffsetToRawOffset(*dol_offset + *dol_size, partition);
+        biggest_offset = std::max(biggest_offset, offset);
+      }
+    }
+
+    const std::optional<u64> fst_offset = GetFSTOffset(volume, partition);
+    const std::optional<u64> fst_size = GetFSTSize(volume, partition);
+    if (fst_offset && fst_size)
+    {
+      const u64 offset = volume.PartitionOffsetToRawOffset(*fst_offset + *fst_size, partition);
+      biggest_offset = std::max(biggest_offset, offset);
+    }
+
+    const FileSystem* fs = volume.GetFileSystem(partition);
+    if (fs)
+    {
+      const u64 offset_in_partition = GetBiggestReferencedOffset(volume, fs->GetRoot());
+      const u64 offset = volume.PartitionOffsetToRawOffset(offset_in_partition, partition);
+      biggest_offset = std::max(biggest_offset, offset);
+    }
+  }
+  return biggest_offset;
+}
+
+}  // namespace DiscIO
diff --git a/Source/Core/DiscIO/DiscUtils.h b/Source/Core/DiscIO/DiscUtils.h
new file mode 100644
index 0000000000..91bf3eaece
--- /dev/null
+++ b/Source/Core/DiscIO/DiscUtils.h
@@ -0,0 +1,43 @@
+// Copyright 2021 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "Common/CommonTypes.h"
+
+namespace DiscIO
+{
+class FileInfo;
+struct Partition;
+class Volume;
+
+constexpr u64 MINI_DVD_SIZE = 1459978240;  // GameCube
+constexpr u64 SL_DVD_SIZE = 4699979776;    // Wii retail
+constexpr u64 SL_DVD_R_SIZE = 4707319808;  // Wii RVT-R
+constexpr u64 DL_DVD_SIZE = 8511160320;    // Wii retail
+constexpr u64 DL_DVD_R_SIZE = 8543666176;  // Wii RVT-R
+
+constexpr u32 GAMECUBE_DISC_MAGIC = 0xC2339F3D;
+constexpr u32 WII_DISC_MAGIC = 0x5D1C9EA3;
+
+constexpr u32 PARTITION_DATA = 0;
+constexpr u32 PARTITION_UPDATE = 1;
+constexpr u32 PARTITION_CHANNEL = 2;  // Mario Kart Wii, Wii Fit, Wii Fit Plus, Rabbids Go Home
+constexpr u32 PARTITION_INSTALL = 3;  // Dragon Quest X only
+
+std::string NameForPartitionType(u32 partition_type, bool include_prefix);
+
+std::optional<u64> GetApploaderSize(const Volume& volume, const Partition& partition);
+std::optional<u64> GetBootDOLOffset(const Volume& volume, const Partition& partition);
+std::optional<u32> GetBootDOLSize(const Volume& volume, const Partition& partition, u64 dol_offset);
+std::optional<u64> GetFSTOffset(const Volume& volume, const Partition& partition);
+std::optional<u64> GetFSTSize(const Volume& volume, const Partition& partition);
+
+u64 GetBiggestReferencedOffset(const Volume& volume);
+u64 GetBiggestReferencedOffset(const Volume& volume, const std::vector<Partition>& partitions);
+}  // namespace DiscIO
diff --git a/Source/Core/DiscIO/FileSystemGCWii.cpp b/Source/Core/DiscIO/FileSystemGCWii.cpp
index c706e809a8..5b64931be7 100644
--- a/Source/Core/DiscIO/FileSystemGCWii.cpp
+++ b/Source/Core/DiscIO/FileSystemGCWii.cpp
@@ -19,7 +19,7 @@
 #include "Common/Logging/Log.h"
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
-#include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/FileSystemGCWii.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/VolumeDisc.h"
@@ -232,9 +232,9 @@ FileSystemGCWii::FileSystemGCWii(const VolumeDisc* volume, const Partition& part
 {
   u8 offset_shift;
   // Check if this is a GameCube or Wii disc
-  if (volume->ReadSwapped<u32>(0x18, partition) == u32(0x5D1C9EA3))
+  if (volume->ReadSwapped<u32>(0x18, partition) == WII_DISC_MAGIC)
     offset_shift = 2;  // Wii file system
-  else if (volume->ReadSwapped<u32>(0x1c, partition) == u32(0xC2339F3D))
+  else if (volume->ReadSwapped<u32>(0x1c, partition) == GAMECUBE_DISC_MAGIC)
     offset_shift = 0;  // GameCube file system
   else
     return;  // Invalid partition (maybe someone removed its data but not its partition table entry)
diff --git a/Source/Core/DiscIO/Volume.cpp b/Source/Core/DiscIO/Volume.cpp
index ab4b0e562b..911a486a4e 100644
--- a/Source/Core/DiscIO/Volume.cpp
+++ b/Source/Core/DiscIO/Volume.cpp
@@ -20,6 +20,7 @@
 
 #include "Core/IOS/ES/Formats.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/VolumeDisc.h"
 #include "DiscIO/VolumeGC.h"
@@ -87,14 +88,10 @@ std::map<Language, std::string> Volume::ReadWiiNames(const std::vector<char16_t>
 
 static std::unique_ptr<VolumeDisc> CreateDisc(std::unique_ptr<BlobReader>& reader)
 {
-  // Check for Wii
-  const std::optional<u32> wii_magic = reader->ReadSwapped<u32>(0x18);
-  if (wii_magic == u32(0x5D1C9EA3))
+  if (reader->ReadSwapped<u32>(0x18) == WII_DISC_MAGIC)
     return std::make_unique<VolumeWii>(std::move(reader));
 
-  // Check for GC
-  const std::optional<u32> gc_magic = reader->ReadSwapped<u32>(0x1C);
-  if (gc_magic == u32(0xC2339F3D))
+  if (reader->ReadSwapped<u32>(0x1C) == GAMECUBE_DISC_MAGIC)
     return std::make_unique<VolumeGC>(std::move(reader));
 
   // No known magic words found
diff --git a/Source/Core/DiscIO/VolumeDisc.cpp b/Source/Core/DiscIO/VolumeDisc.cpp
index 3ccea4b62f..ec23922274 100644
--- a/Source/Core/DiscIO/VolumeDisc.cpp
+++ b/Source/Core/DiscIO/VolumeDisc.cpp
@@ -12,7 +12,7 @@
 #include <mbedtls/sha1.h>
 
 #include "Common/CommonTypes.h"
-#include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/Filesystem.h"
 
diff --git a/Source/Core/DiscIO/VolumeGC.cpp b/Source/Core/DiscIO/VolumeGC.cpp
index e8bab67771..d47f9c5735 100644
--- a/Source/Core/DiscIO/VolumeGC.cpp
+++ b/Source/Core/DiscIO/VolumeGC.cpp
@@ -23,6 +23,7 @@
 
 #include "DiscIO/Blob.h"
 #include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/FileSystemGCWii.h"
 #include "DiscIO/Filesystem.h"
diff --git a/Source/Core/DiscIO/VolumeVerifier.cpp b/Source/Core/DiscIO/VolumeVerifier.cpp
index 21ac8f5d39..79c589f5c1 100644
--- a/Source/Core/DiscIO/VolumeVerifier.cpp
+++ b/Source/Core/DiscIO/VolumeVerifier.cpp
@@ -41,8 +41,8 @@
 #include "Core/IOS/IOS.h"
 #include "Core/IOS/IOSC.h"
 #include "DiscIO/Blob.h"
-#include "DiscIO/DiscExtractor.h"
 #include "DiscIO/DiscScrubber.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Enums.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
@@ -358,12 +358,6 @@ RedumpVerifier::Result RedumpVerifier::Finish(const Hashes<std::vector<u8>>& has
   return {Status::Unknown, Common::GetStringT("Unknown disc")};
 }
 
-constexpr u64 MINI_DVD_SIZE = 1459978240;  // GameCube
-constexpr u64 SL_DVD_SIZE = 4699979776;    // Wii retail
-constexpr u64 SL_DVD_R_SIZE = 4707319808;  // Wii RVT-R
-constexpr u64 DL_DVD_SIZE = 8511160320;    // Wii retail
-constexpr u64 DL_DVD_R_SIZE = 8543666176;  // Wii RVT-R
-
 constexpr u64 BLOCK_SIZE = 0x20000;
 
 VolumeVerifier::VolumeVerifier(const Volume& volume, bool redump_verification,
@@ -397,7 +391,7 @@ void VolumeVerifier::Start()
   const std::vector<Partition> partitions = CheckPartitions();
 
   if (IsDisc(m_volume.GetVolumeType()))
-    m_biggest_referenced_offset = GetBiggestReferencedOffset(partitions);
+    m_biggest_referenced_offset = GetBiggestReferencedOffset(m_volume, partitions);
 
   CheckMisc();
 
@@ -529,12 +523,11 @@ bool VolumeVerifier::CheckPartition(const Partition& partition)
   bool invalid_header = false;
   bool blank_contents = false;
   std::vector<u8> disc_header(0x80);
-  constexpr u32 WII_MAGIC = 0x5D1C9EA3;
   if (!m_volume.Read(0, disc_header.size(), disc_header.data(), partition))
   {
     invalid_header = true;
   }
-  else if (Common::swap32(disc_header.data() + 0x18) != WII_MAGIC)
+  else if (Common::swap32(disc_header.data() + 0x18) != WII_DISC_MAGIC)
   {
     for (size_t i = 0; i < disc_header.size(); i += 4)
     {
@@ -822,63 +815,6 @@ void VolumeVerifier::CheckVolumeSize()
   }
 }
 
-u64 VolumeVerifier::GetBiggestReferencedOffset(const std::vector<Partition>& partitions) const
-{
-  const u64 disc_header_size = m_volume.GetVolumeType() == Platform::GameCubeDisc ? 0x460 : 0x50000;
-  u64 biggest_offset = disc_header_size;
-  for (const Partition& partition : partitions)
-  {
-    if (partition != PARTITION_NONE)
-    {
-      const u64 offset = m_volume.PartitionOffsetToRawOffset(0x440, partition);
-      biggest_offset = std::max(biggest_offset, offset);
-    }
-
-    const std::optional<u64> dol_offset = GetBootDOLOffset(m_volume, partition);
-    if (dol_offset)
-    {
-      const std::optional<u64> dol_size = GetBootDOLSize(m_volume, partition, *dol_offset);
-      if (dol_size)
-      {
-        const u64 offset = m_volume.PartitionOffsetToRawOffset(*dol_offset + *dol_size, partition);
-        biggest_offset = std::max(biggest_offset, offset);
-      }
-    }
-
-    const std::optional<u64> fst_offset = GetFSTOffset(m_volume, partition);
-    const std::optional<u64> fst_size = GetFSTSize(m_volume, partition);
-    if (fst_offset && fst_size)
-    {
-      const u64 offset = m_volume.PartitionOffsetToRawOffset(*fst_offset + *fst_size, partition);
-      biggest_offset = std::max(biggest_offset, offset);
-    }
-
-    const FileSystem* fs = m_volume.GetFileSystem(partition);
-    if (fs)
-    {
-      const u64 offset =
-          m_volume.PartitionOffsetToRawOffset(GetBiggestReferencedOffset(fs->GetRoot()), partition);
-      biggest_offset = std::max(biggest_offset, offset);
-    }
-  }
-  return biggest_offset;
-}
-
-u64 VolumeVerifier::GetBiggestReferencedOffset(const FileInfo& file_info) const
-{
-  if (file_info.IsDirectory())
-  {
-    u64 biggest_offset = 0;
-    for (const FileInfo& f : file_info)
-      biggest_offset = std::max(biggest_offset, GetBiggestReferencedOffset(f));
-    return biggest_offset;
-  }
-  else
-  {
-    return file_info.GetOffset() + file_info.GetSize();
-  }
-}
-
 void VolumeVerifier::CheckMisc()
 {
   const std::string game_id_unencrypted = m_volume.GetGameID(PARTITION_NONE);
diff --git a/Source/Core/DiscIO/VolumeVerifier.h b/Source/Core/DiscIO/VolumeVerifier.h
index 7992335d7b..78c4305107 100644
--- a/Source/Core/DiscIO/VolumeVerifier.h
+++ b/Source/Core/DiscIO/VolumeVerifier.h
@@ -34,8 +34,6 @@
 
 namespace DiscIO
 {
-class FileInfo;
-
 template <typename T>
 struct Hashes
 {
@@ -154,8 +152,6 @@ private:
   bool ShouldHaveMasterpiecePartitions() const;
   bool ShouldBeDualLayer() const;
   void CheckVolumeSize();
-  u64 GetBiggestReferencedOffset(const std::vector<Partition>& partitions) const;
-  u64 GetBiggestReferencedOffset(const FileInfo& file_info) const;
   void CheckMisc();
   void CheckSuperPaperMario();
   void SetUpHashing();
diff --git a/Source/Core/DiscIO/WIABlob.cpp b/Source/Core/DiscIO/WIABlob.cpp
index 8a76b9bd77..07894fa25a 100644
--- a/Source/Core/DiscIO/WIABlob.cpp
+++ b/Source/Core/DiscIO/WIABlob.cpp
@@ -30,7 +30,7 @@
 #include "Common/Swap.h"
 
 #include "DiscIO/Blob.h"
-#include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/LaggedFibonacciGenerator.h"
 #include "DiscIO/MultithreadedCompressor.h"
diff --git a/Source/Core/DolphinLib.props b/Source/Core/DolphinLib.props
index 638e6734e2..9d89aee8b9 100644
--- a/Source/Core/DolphinLib.props
+++ b/Source/Core/DolphinLib.props
@@ -417,6 +417,7 @@
     <ClInclude Include="DiscIO\DirectoryBlob.h" />
     <ClInclude Include="DiscIO\DiscExtractor.h" />
     <ClInclude Include="DiscIO\DiscScrubber.h" />
+    <ClInclude Include="DiscIO\DiscUtils.h" />
     <ClInclude Include="DiscIO\DriveBlob.h" />
     <ClInclude Include="DiscIO\Enums.h" />
     <ClInclude Include="DiscIO\FileBlob.h" />
@@ -991,6 +992,7 @@
     <ClCompile Include="DiscIO\DirectoryBlob.cpp" />
     <ClCompile Include="DiscIO\DiscExtractor.cpp" />
     <ClCompile Include="DiscIO\DiscScrubber.cpp" />
+    <ClCompile Include="DiscIO\DiscUtils.cpp" />
     <ClCompile Include="DiscIO\DriveBlob.cpp" />
     <ClCompile Include="DiscIO\Enums.cpp" />
     <ClCompile Include="DiscIO\FileBlob.cpp" />
diff --git a/Source/Core/DolphinQt/Config/FilesystemWidget.cpp b/Source/Core/DolphinQt/Config/FilesystemWidget.cpp
index ddffe76963..09ab45a6c4 100644
--- a/Source/Core/DolphinQt/Config/FilesystemWidget.cpp
+++ b/Source/Core/DolphinQt/Config/FilesystemWidget.cpp
@@ -18,6 +18,7 @@
 #include <future>
 
 #include "DiscIO/DiscExtractor.h"
+#include "DiscIO/DiscUtils.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"