Merge pull request #9718 from Pokechu22/better-fifo-analyzer-part-3

Fifo analyzer improvements, part 3
2026-06-19 01:16:48 -07:00 · 2021-12-20 14:27:14 -05:00
parent 1714dc64bb ffa512f5e7
commit 32fed91b0d
66 changed files with 2757 additions and 2695 deletions
@@ -55,9 +55,9 @@ public:
  constexpr auto parse(fmt::format_parse_context& ctx)
  {
    auto it = ctx.begin(), end = ctx.end();
-    // 'u' for user display, 's' for shader generation
-    if (it != end && (*it == 'u' || *it == 's'))
-      formatting_for_shader = (*it++ == 's');
+    // 'u' for user display, 's' for shader generation, 'n' for name only
+    if (it != end && (*it == 'u' || *it == 's' || *it == 'n'))
+      format_type = *it++;
    return it;
  }

@@ -68,19 +68,24 @@ public:
    const auto value_u = static_cast<std::make_unsigned_t<T>>(value_s);  // Always unsigned
    const bool has_name = m_names.InBounds(e) && m_names[e] != nullptr;

-    if (!formatting_for_shader)
+    switch (format_type)
    {
+    default:
+    case 'u':
      if (has_name)
        return fmt::format_to(ctx.out(), "{} ({})", m_names[e], value_s);
      else
        return fmt::format_to(ctx.out(), "Invalid ({})", value_s);
-    }
-    else
-    {
+    case 's':
      if (has_name)
        return fmt::format_to(ctx.out(), "{:#x}u /* {} */", value_u, m_names[e]);
      else
        return fmt::format_to(ctx.out(), "{:#x}u /* Invalid */", value_u);
+    case 'n':
+      if (has_name)
+        return fmt::format_to(ctx.out(), "{}", m_names[e]);
+      else
+        return fmt::format_to(ctx.out(), "Invalid ({})", value_s);
    }
  }

@@ -92,5 +97,5 @@ protected:

 private:
  const array_type m_names;
-  bool formatting_for_shader = false;
+  char format_type = 'u';
 };
@@ -103,16 +103,10 @@ add_library(core
  DSP/LabelMap.h
  DSPEmulator.cpp
  DSPEmulator.h
-  FifoPlayer/FifoAnalyzer.cpp
-  FifoPlayer/FifoAnalyzer.h
  FifoPlayer/FifoDataFile.cpp
  FifoPlayer/FifoDataFile.h
-  FifoPlayer/FifoPlaybackAnalyzer.cpp
-  FifoPlayer/FifoPlaybackAnalyzer.h
  FifoPlayer/FifoPlayer.cpp
  FifoPlayer/FifoPlayer.h
-  FifoPlayer/FifoRecordAnalyzer.cpp
-  FifoPlayer/FifoRecordAnalyzer.h
  FifoPlayer/FifoRecorder.cpp
  FifoPlayer/FifoRecorder.h
  FreeLookConfig.cpp
@@ -1,294 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "Core/FifoPlayer/FifoAnalyzer.h"
-
-#include <numeric>
-
-#include "Common/Assert.h"
-#include "Common/MsgHandler.h"
-#include "Common/Swap.h"
-
-#include "Core/FifoPlayer/FifoRecordAnalyzer.h"
-
-#include "VideoCommon/OpcodeDecoding.h"
-#include "VideoCommon/VertexLoader.h"
-#include "VideoCommon/VertexLoader_Normal.h"
-#include "VideoCommon/VertexLoader_Position.h"
-#include "VideoCommon/VertexLoader_TextCoord.h"
-
-namespace FifoAnalyzer
-{
-namespace
-{
-u8 ReadFifo8(const u8*& data)
-{
-  const u8 value = data[0];
-  data += 1;
-  return value;
-}
-
-u16 ReadFifo16(const u8*& data)
-{
-  const u16 value = Common::swap16(data);
-  data += 2;
-  return value;
-}
-
-u32 ReadFifo32(const u8*& data)
-{
-  const u32 value = Common::swap32(data);
-  data += 4;
-  return value;
-}
-
-std::array<int, 21> CalculateVertexElementSizes(int vatIndex, const CPMemory& cpMem)
-{
-  const TVtxDesc& vtxDesc = cpMem.vtxDesc;
-  const VAT& vtxAttr = cpMem.vtxAttr[vatIndex];
-
-  // Colors
-  const std::array<ColorFormat, 2> colComp{
-      vtxAttr.g0.Color0Comp,
-      vtxAttr.g0.Color1Comp,
-  };
-
-  const std::array<TexComponentCount, 8> tcElements{
-      vtxAttr.g0.Tex0CoordElements, vtxAttr.g1.Tex1CoordElements, vtxAttr.g1.Tex2CoordElements,
-      vtxAttr.g1.Tex3CoordElements, vtxAttr.g1.Tex4CoordElements, vtxAttr.g2.Tex5CoordElements,
-      vtxAttr.g2.Tex6CoordElements, vtxAttr.g2.Tex7CoordElements,
-  };
-  const std::array<ComponentFormat, 8> tcFormat{
-      vtxAttr.g0.Tex0CoordFormat, vtxAttr.g1.Tex1CoordFormat, vtxAttr.g1.Tex2CoordFormat,
-      vtxAttr.g1.Tex3CoordFormat, vtxAttr.g1.Tex4CoordFormat, vtxAttr.g2.Tex5CoordFormat,
-      vtxAttr.g2.Tex6CoordFormat, vtxAttr.g2.Tex7CoordFormat,
-  };
-
-  std::array<int, 21> sizes{};
-
-  // Add position and texture matrix indices
-  sizes[0] = vtxDesc.low.PosMatIdx;
-  for (size_t i = 0; i < vtxDesc.low.TexMatIdx.Size(); ++i)
-  {
-    sizes[i + 1] = vtxDesc.low.TexMatIdx[i];
-  }
-
-  // Position
-  sizes[9] = VertexLoader_Position::GetSize(vtxDesc.low.Position, vtxAttr.g0.PosFormat,
-                                            vtxAttr.g0.PosElements);
-
-  // Normals
-  if (vtxDesc.low.Normal != VertexComponentFormat::NotPresent)
-  {
-    sizes[10] = VertexLoader_Normal::GetSize(vtxDesc.low.Normal, vtxAttr.g0.NormalFormat,
-                                             vtxAttr.g0.NormalElements, vtxAttr.g0.NormalIndex3);
-  }
-  else
-  {
-    sizes[10] = 0;
-  }
-
-  // Colors
-  for (size_t i = 0; i < vtxDesc.low.Color.Size(); i++)
-  {
-    int size = 0;
-
-    switch (vtxDesc.low.Color[i])
-    {
-    case VertexComponentFormat::NotPresent:
-      break;
-    case VertexComponentFormat::Direct:
-      switch (colComp[i])
-      {
-      case ColorFormat::RGB565:
-        size = 2;
-        break;
-      case ColorFormat::RGB888:
-        size = 3;
-        break;
-      case ColorFormat::RGB888x:
-        size = 4;
-        break;
-      case ColorFormat::RGBA4444:
-        size = 2;
-        break;
-      case ColorFormat::RGBA6666:
-        size = 3;
-        break;
-      case ColorFormat::RGBA8888:
-        size = 4;
-        break;
-      default:
-        ASSERT(0);
-        break;
-      }
-      break;
-    case VertexComponentFormat::Index8:
-      size = 1;
-      break;
-    case VertexComponentFormat::Index16:
-      size = 2;
-      break;
-    }
-
-    sizes[11 + i] = size;
-  }
-
-  // Texture coordinates
-  for (size_t i = 0; i < tcFormat.size(); i++)
-  {
-    sizes[13 + i] =
-        VertexLoader_TextCoord::GetSize(vtxDesc.high.TexCoord[i], tcFormat[i], tcElements[i]);
-  }
-
-  return sizes;
-}
-}  // Anonymous namespace
-
-bool s_DrawingObject;
-FifoAnalyzer::CPMemory s_CpMem;
-
-u32 AnalyzeCommand(const u8* data, DecodeMode mode)
-{
-  const u8* dataStart = data;
-
-  int cmd = ReadFifo8(data);
-
-  switch (cmd)
-  {
-  case OpcodeDecoder::GX_NOP:
-  case OpcodeDecoder::GX_CMD_UNKNOWN_METRICS:
-  case OpcodeDecoder::GX_CMD_INVL_VC:
-    break;
-
-  case OpcodeDecoder::GX_LOAD_CP_REG:
-  {
-    s_DrawingObject = false;
-
-    u32 cmd2 = ReadFifo8(data);
-    u32 value = ReadFifo32(data);
-    LoadCPReg(cmd2, value, s_CpMem);
-    break;
-  }
-
-  case OpcodeDecoder::GX_LOAD_XF_REG:
-  {
-    s_DrawingObject = false;
-
-    u32 cmd2 = ReadFifo32(data);
-    u8 streamSize = ((cmd2 >> 16) & 15) + 1;
-
-    data += streamSize * 4;
-    break;
-  }
-
-  case OpcodeDecoder::GX_LOAD_INDX_A:
-  case OpcodeDecoder::GX_LOAD_INDX_B:
-  case OpcodeDecoder::GX_LOAD_INDX_C:
-  case OpcodeDecoder::GX_LOAD_INDX_D:
-  {
-    s_DrawingObject = false;
-
-    int array = 0xc + (cmd - OpcodeDecoder::GX_LOAD_INDX_A) / 8;
-    u32 value = ReadFifo32(data);
-
-    if (mode == DecodeMode::Record)
-      FifoRecordAnalyzer::ProcessLoadIndexedXf(value, array);
-    break;
-  }
-
-  case OpcodeDecoder::GX_CMD_CALL_DL:
-    // The recorder should have expanded display lists into the fifo stream and skipped the call to
-    // start them
-    // That is done to make it easier to track where memory is updated
-    ASSERT(false);
-    data += 8;
-    break;
-
-  case OpcodeDecoder::GX_LOAD_BP_REG:
-  {
-    s_DrawingObject = false;
-    ReadFifo32(data);
-    break;
-  }
-
-  default:
-    if (cmd & 0x80)
-    {
-      s_DrawingObject = true;
-
-      const std::array<int, 21> sizes =
-          CalculateVertexElementSizes(cmd & OpcodeDecoder::GX_VAT_MASK, s_CpMem);
-
-      // Determine offset of each element that might be a vertex array
-      // The first 9 elements are never vertex arrays so we just accumulate their sizes.
-      int offset = std::accumulate(sizes.begin(), sizes.begin() + 9, 0u);
-      std::array<int, NUM_VERTEX_COMPONENT_ARRAYS> offsets;
-      for (size_t i = 0; i < offsets.size(); ++i)
-      {
-        offsets[i] = offset;
-        offset += sizes[i + 9];
-      }
-
-      const int vertexSize = offset;
-      const int numVertices = ReadFifo16(data);
-
-      if (mode == DecodeMode::Record && numVertices > 0)
-      {
-        for (size_t i = 0; i < offsets.size(); ++i)
-        {
-          FifoRecordAnalyzer::WriteVertexArray(static_cast<int>(i), data + offsets[i], vertexSize,
-                                               numVertices);
-        }
-      }
-
-      data += numVertices * vertexSize;
-    }
-    else
-    {
-      PanicAlertFmt("FifoPlayer: Unknown Opcode ({:#x}).\n", cmd);
-      return 0;
-    }
-    break;
-  }
-
-  return (u32)(data - dataStart);
-}
-
-void LoadCPReg(u32 subCmd, u32 value, CPMemory& cpMem)
-{
-  switch (subCmd & CP_COMMAND_MASK)
-  {
-  case VCD_LO:
-    cpMem.vtxDesc.low.Hex = value;
-    break;
-
-  case VCD_HI:
-    cpMem.vtxDesc.high.Hex = value;
-    break;
-
-  case CP_VAT_REG_A:
-    ASSERT(subCmd - CP_VAT_REG_A < CP_NUM_VAT_REG);
-    cpMem.vtxAttr[subCmd & CP_VAT_MASK].g0.Hex = value;
-    break;
-
-  case CP_VAT_REG_B:
-    ASSERT(subCmd - CP_VAT_REG_B < CP_NUM_VAT_REG);
-    cpMem.vtxAttr[subCmd & CP_VAT_MASK].g1.Hex = value;
-    break;
-
-  case CP_VAT_REG_C:
-    ASSERT(subCmd - CP_VAT_REG_C < CP_NUM_VAT_REG);
-    cpMem.vtxAttr[subCmd & CP_VAT_MASK].g2.Hex = value;
-    break;
-
-  case ARRAY_BASE:
-    cpMem.arrayBases[subCmd & CP_ARRAY_MASK] = value;
-    break;
-
-  case ARRAY_STRIDE:
-    cpMem.arrayStrides[subCmd & CP_ARRAY_MASK] = value & 0xFF;
-    break;
-  }
-}
-}  // namespace FifoAnalyzer
@@ -1,33 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-
-#include "Common/CommonTypes.h"
-#include "VideoCommon/CPMemory.h"
-
-namespace FifoAnalyzer
-{
-enum class DecodeMode
-{
-  Record,
-  Playback,
-};
-
-u32 AnalyzeCommand(const u8* data, DecodeMode mode);
-
-struct CPMemory
-{
-  TVtxDesc vtxDesc;
-  std::array<VAT, CP_NUM_VAT_REG> vtxAttr;
-  std::array<u32, CP_NUM_ARRAYS> arrayBases{};
-  std::array<u32, CP_NUM_ARRAYS> arrayStrides{};
-};
-
-void LoadCPReg(u32 subCmd, u32 value, CPMemory& cpMem);
-
-extern bool s_DrawingObject;
-extern FifoAnalyzer::CPMemory s_CpMem;
-}  // namespace FifoAnalyzer
@@ -1,111 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "Core/FifoPlayer/FifoPlaybackAnalyzer.h"
-
-#include <vector>
-
-#include "Common/Assert.h"
-#include "Common/CommonTypes.h"
-#include "Core/FifoPlayer/FifoAnalyzer.h"
-#include "Core/FifoPlayer/FifoDataFile.h"
-
-using namespace FifoAnalyzer;
-
-// For debugging
-#define LOG_FIFO_CMDS 0
-struct CmdData
-{
-  u32 size;
-  u32 offset;
-  const u8* ptr;
-};
-
-void FifoPlaybackAnalyzer::AnalyzeFrames(FifoDataFile* file,
-                                         std::vector<AnalyzedFrameInfo>& frameInfo)
-{
-  u32* cpMem = file->GetCPMem();
-  FifoAnalyzer::LoadCPReg(VCD_LO, cpMem[VCD_LO], s_CpMem);
-  FifoAnalyzer::LoadCPReg(VCD_HI, cpMem[VCD_HI], s_CpMem);
-
-  for (u32 i = 0; i < CP_NUM_VAT_REG; ++i)
-  {
-    FifoAnalyzer::LoadCPReg(CP_VAT_REG_A + i, cpMem[CP_VAT_REG_A + i], s_CpMem);
-    FifoAnalyzer::LoadCPReg(CP_VAT_REG_B + i, cpMem[CP_VAT_REG_B + i], s_CpMem);
-    FifoAnalyzer::LoadCPReg(CP_VAT_REG_C + i, cpMem[CP_VAT_REG_C + i], s_CpMem);
-  }
-
-  frameInfo.clear();
-  frameInfo.resize(file->GetFrameCount());
-
-  for (u32 frameIdx = 0; frameIdx < file->GetFrameCount(); ++frameIdx)
-  {
-    const FifoFrameInfo& frame = file->GetFrame(frameIdx);
-    AnalyzedFrameInfo& analyzed = frameInfo[frameIdx];
-
-    s_DrawingObject = false;
-
-    u32 cmdStart = 0;
-    u32 nextMemUpdate = 0;
-
-#if LOG_FIFO_CMDS
-    // Debugging
-    std::vector<CmdData> prevCmds;
-#endif
-
-    while (cmdStart < frame.fifoData.size())
-    {
-      // Add memory updates that have occurred before this point in the frame
-      while (nextMemUpdate < frame.memoryUpdates.size() &&
-             frame.memoryUpdates[nextMemUpdate].fifoPosition <= cmdStart)
-      {
-        analyzed.memoryUpdates.push_back(frame.memoryUpdates[nextMemUpdate]);
-        ++nextMemUpdate;
-      }
-
-      const bool wasDrawing = s_DrawingObject;
-      const u32 cmdSize =
-          FifoAnalyzer::AnalyzeCommand(&frame.fifoData[cmdStart], DecodeMode::Playback);
-
-#if LOG_FIFO_CMDS
-      CmdData cmdData;
-      cmdData.offset = cmdStart;
-      cmdData.ptr = &frame.fifoData[cmdStart];
-      cmdData.size = cmdSize;
-      prevCmds.push_back(cmdData);
-#endif
-
-      // Check for error
-      if (cmdSize == 0)
-      {
-        // Clean up frame analysis
-        analyzed.objectStarts.clear();
-        analyzed.objectCPStates.clear();
-        analyzed.objectEnds.clear();
-
-        return;
-      }
-
-      if (wasDrawing != s_DrawingObject)
-      {
-        if (s_DrawingObject)
-        {
-          analyzed.objectStarts.push_back(cmdStart);
-          analyzed.objectCPStates.push_back(s_CpMem);
-        }
-        else
-        {
-          analyzed.objectEnds.push_back(cmdStart);
-        }
-      }
-
-      cmdStart += cmdSize;
-    }
-
-    if (analyzed.objectEnds.size() < analyzed.objectStarts.size())
-      analyzed.objectEnds.push_back(cmdStart);
-
-    ASSERT(analyzed.objectStarts.size() == analyzed.objectCPStates.size());
-    ASSERT(analyzed.objectStarts.size() == analyzed.objectEnds.size());
-  }
-}
@@ -1,25 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "Core/FifoPlayer/FifoAnalyzer.h"
-#include "Core/FifoPlayer/FifoDataFile.h"
-
-struct AnalyzedFrameInfo
-{
-  // Start of the primitives for the object (after previous update commands)
-  std::vector<u32> objectStarts;
-  std::vector<FifoAnalyzer::CPMemory> objectCPStates;
-  // End of the primitives for the object
-  std::vector<u32> objectEnds;
-  std::vector<MemoryUpdate> memoryUpdates;
-};
-
-namespace FifoPlaybackAnalyzer
-{
-void AnalyzeFrames(FifoDataFile* file, std::vector<AnalyzedFrameInfo>& frameInfo);
-}  // namespace FifoPlaybackAnalyzer
@@ -4,6 +4,7 @@
 #include "Core/FifoPlayer/FifoPlayer.h"

 #include <algorithm>
+#include <cstring>
 #include <mutex>

 #include "Common/Assert.h"
@@ -12,7 +13,6 @@
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
 #include "Core/CoreTiming.h"
-#include "Core/FifoPlayer/FifoAnalyzer.h"
 #include "Core/FifoPlayer/FifoDataFile.h"
 #include "Core/HW/CPU.h"
 #include "Core/HW/GPFifo.h"
@@ -31,6 +31,136 @@
 // TODO: Move texMem somewhere else so this isn't an issue.
 #include "VideoCommon/TextureDecoder.h"

+namespace
+{
+class FifoPlaybackAnalyzer : public OpcodeDecoder::Callback
+{
+public:
+  static void AnalyzeFrames(FifoDataFile* file, std::vector<AnalyzedFrameInfo>& frame_info);
+
+  explicit FifoPlaybackAnalyzer(const u32* cpmem) : m_cpmem(cpmem) {}
+
+  OPCODE_CALLBACK(void OnXF(u16 address, u8 count, const u8* data)) {}
+  OPCODE_CALLBACK(void OnCP(u8 command, u32 value)) { GetCPState().LoadCPReg(command, value); }
+  OPCODE_CALLBACK(void OnBP(u8 command, u32 value));
+  OPCODE_CALLBACK(void OnIndexedLoad(CPArray array, u32 index, u16 address, u8 size)) {}
+  OPCODE_CALLBACK(void OnPrimitiveCommand(OpcodeDecoder::Primitive primitive, u8 vat,
+                                          u32 vertex_size, u16 num_vertices,
+                                          const u8* vertex_data));
+  OPCODE_CALLBACK(void OnDisplayList(u32 address, u32 size)) {}
+  OPCODE_CALLBACK(void OnNop(u32 count));
+  OPCODE_CALLBACK(void OnUnknown(u8 opcode, const u8* data)) {}
+
+  OPCODE_CALLBACK(void OnCommand(const u8* data, u32 size));
+
+  OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
+
+  bool m_start_of_primitives = false;
+  bool m_end_of_primitives = false;
+  bool m_efb_copy = false;
+  // Internal state, copied to above in OnCommand
+  bool m_was_primitive = false;
+  bool m_is_primitive = false;
+  bool m_is_copy = false;
+  bool m_is_nop = false;
+  CPState m_cpmem;
+};
+
+void FifoPlaybackAnalyzer::AnalyzeFrames(FifoDataFile* file,
+                                         std::vector<AnalyzedFrameInfo>& frame_info)
+{
+  FifoPlaybackAnalyzer analyzer(file->GetCPMem());
+  frame_info.clear();
+  frame_info.resize(file->GetFrameCount());
+
+  for (u32 frame_no = 0; frame_no < file->GetFrameCount(); frame_no++)
+  {
+    const FifoFrameInfo& frame = file->GetFrame(frame_no);
+    AnalyzedFrameInfo& analyzed = frame_info[frame_no];
+
+    u32 offset = 0;
+
+    u32 part_start = 0;
+    CPState cpmem;
+
+    while (offset < frame.fifoData.size())
+    {
+      const u32 cmd_size = OpcodeDecoder::RunCommand(&frame.fifoData[offset],
+                                                     u32(frame.fifoData.size()) - offset, analyzer);
+
+      if (analyzer.m_start_of_primitives)
+      {
+        // Start of primitive data for an object
+        analyzed.AddPart(FramePartType::Commands, part_start, offset, analyzer.m_cpmem);
+        part_start = offset;
+        // Copy cpmem now, because end_of_primitives isn't triggered until the first opcode after
+        // primitive data, and the first opcode might update cpmem
+        std::memcpy(&cpmem, &analyzer.m_cpmem, sizeof(CPState));
+      }
+      if (analyzer.m_end_of_primitives)
+      {
+        // End of primitive data for an object, and thus end of the object
+        analyzed.AddPart(FramePartType::PrimitiveData, part_start, offset, cpmem);
+        part_start = offset;
+      }
+
+      offset += cmd_size;
+
+      if (analyzer.m_efb_copy)
+      {
+        // We increase the offset beforehand, so that the trigger EFB copy command is included.
+        analyzed.AddPart(FramePartType::EFBCopy, part_start, offset, analyzer.m_cpmem);
+        part_start = offset;
+      }
+    }
+
+    // The frame should end with an EFB copy, so part_start should have been updated to the end.
+    ASSERT(part_start == frame.fifoData.size());
+    ASSERT(offset == frame.fifoData.size());
+  }
+}
+
+void FifoPlaybackAnalyzer::OnBP(u8 command, u32 value)
+{
+  if (command == BPMEM_TRIGGER_EFB_COPY)
+    m_is_copy = true;
+}
+
+void FifoPlaybackAnalyzer::OnPrimitiveCommand(OpcodeDecoder::Primitive primitive, u8 vat,
+                                              u32 vertex_size, u16 num_vertices,
+                                              const u8* vertex_data)
+{
+  m_is_primitive = true;
+}
+
+void FifoPlaybackAnalyzer::OnNop(u32 count)
+{
+  m_is_nop = true;
+}
+
+void FifoPlaybackAnalyzer::OnCommand(const u8* data, u32 size)
+{
+  m_start_of_primitives = false;
+  m_end_of_primitives = false;
+  m_efb_copy = false;
+
+  if (!m_is_nop)
+  {
+    if (m_is_primitive && !m_was_primitive)
+      m_start_of_primitives = true;
+    else if (m_was_primitive && !m_is_primitive)
+      m_end_of_primitives = true;
+    else if (m_is_copy)
+      m_efb_copy = true;
+
+    m_was_primitive = m_is_primitive;
+  }
+  m_is_primitive = false;
+  m_is_copy = false;
+  m_is_nop = false;
+}
+}  // namespace
+
 bool IsPlayingBackFifologWithBrokenEFBCopies = false;

 FifoPlayer::FifoPlayer() : m_Loop{SConfig::GetInstance().bLoopFifoReplay}
@@ -191,7 +321,7 @@ u32 FifoPlayer::GetMaxObjectCount() const
  u32 result = 0;
  for (auto& frame : m_FrameInfo)
  {
-    const u32 count = static_cast<u32>(frame.objectStarts.size());
+    const u32 count = frame.part_type_counts[FramePartType::PrimitiveData];
    if (count > result)
      result = count;
  }
@@ -202,7 +332,7 @@ u32 FifoPlayer::GetFrameObjectCount(u32 frame) const
 {
  if (frame < m_FrameInfo.size())
  {
-    return static_cast<u32>(m_FrameInfo[frame].objectStarts.size());
+    return m_FrameInfo[frame].part_type_counts[FramePartType::PrimitiveData];
  }

  return 0;
@@ -262,55 +392,35 @@ void FifoPlayer::WriteFrame(const FifoFrameInfo& frame, const AnalyzedFrameInfo&
  m_ElapsedCycles = 0;
  m_FrameFifoSize = static_cast<u32>(frame.fifoData.size());

-  // Determine start and end objects
-  u32 numObjects = (u32)(info.objectStarts.size());
-  u32 drawStart = std::min(numObjects, m_ObjectRangeStart);
-  u32 drawEnd = std::min(numObjects - 1, m_ObjectRangeEnd);
+  u32 memory_update = 0;
+  u32 object_num = 0;

-  u32 position = 0;
-  u32 memoryUpdate = 0;
-
-  // Skip memory updates during frame if true
+  // Skip all memory updates if early memory updates are enabled, as we already wrote them
  if (m_EarlyMemoryUpdates)
  {
-    memoryUpdate = (u32)(frame.memoryUpdates.size());
+    memory_update = (u32)(frame.memoryUpdates.size());
  }

-  if (numObjects > 0)
+  for (const FramePart& part : info.parts)
  {
-    u32 objectNum = 0;
+    bool show_part;

-    // Write fifo data skipping objects before the draw range
-    while (objectNum < drawStart)
+    if (part.m_type == FramePartType::PrimitiveData)
    {
-      WriteFramePart(position, info.objectStarts[objectNum], memoryUpdate, frame, info);
-
-      position = info.objectEnds[objectNum];
-      ++objectNum;
+      show_part = m_ObjectRangeStart <= object_num && object_num <= m_ObjectRangeEnd;
+      object_num++;
+    }
+    else
+    {
+      // We always include commands and EFB copies, as commands from earlier objects still apply to
+      // later ones (games generally do not reconfigure everything for each object)
+      show_part = true;
    }

-    // Write objects in draw range
-    if (objectNum < numObjects && drawStart <= drawEnd)
-    {
-      objectNum = drawEnd;
-      WriteFramePart(position, info.objectEnds[objectNum], memoryUpdate, frame, info);
-      position = info.objectEnds[objectNum];
-      ++objectNum;
-    }
-
-    // Write fifo data skipping objects after the draw range
-    while (objectNum < numObjects)
-    {
-      WriteFramePart(position, info.objectStarts[objectNum], memoryUpdate, frame, info);
-
-      position = info.objectEnds[objectNum];
-      ++objectNum;
-    }
+    if (show_part)
+      WriteFramePart(part, &memory_update, frame);
  }

-  // Write data after the last object
-  WriteFramePart(position, static_cast<u32>(frame.fifoData.size()), memoryUpdate, frame, info);
-
  FlushWGP();

  // Sleep while the GPU is active
@@ -321,36 +431,39 @@ void FifoPlayer::WriteFrame(const FifoFrameInfo& frame, const AnalyzedFrameInfo&
  }
 }

-void FifoPlayer::WriteFramePart(u32 dataStart, u32 dataEnd, u32& nextMemUpdate,
-                                const FifoFrameInfo& frame, const AnalyzedFrameInfo& info)
+void FifoPlayer::WriteFramePart(const FramePart& part, u32* next_mem_update,
+                                const FifoFrameInfo& frame)
 {
  const u8* const data = frame.fifoData.data();

-  while (nextMemUpdate < frame.memoryUpdates.size() && dataStart < dataEnd)
-  {
-    const MemoryUpdate& memUpdate = info.memoryUpdates[nextMemUpdate];
+  u32 data_start = part.m_start;
+  const u32 data_end = part.m_end;

-    if (memUpdate.fifoPosition < dataEnd)
+  while (*next_mem_update < frame.memoryUpdates.size() && data_start < data_end)
+  {
+    const MemoryUpdate& memUpdate = frame.memoryUpdates[*next_mem_update];
+
+    if (memUpdate.fifoPosition < data_end)
    {
-      if (dataStart < memUpdate.fifoPosition)
+      if (data_start < memUpdate.fifoPosition)
      {
-        WriteFifo(data, dataStart, memUpdate.fifoPosition);
-        dataStart = memUpdate.fifoPosition;
+        WriteFifo(data, data_start, memUpdate.fifoPosition);
+        data_start = memUpdate.fifoPosition;
      }

      WriteMemory(memUpdate);

-      ++nextMemUpdate;
+      ++*next_mem_update;
    }
    else
    {
-      WriteFifo(data, dataStart, dataEnd);
-      dataStart = dataEnd;
+      WriteFifo(data, data_start, data_end);
+      data_start = data_end;
    }
  }

-  if (dataStart < dataEnd)
-    WriteFifo(data, dataStart, dataEnd);
+  if (data_start < data_end)
+    WriteFifo(data, data_start, data_end);
 }

 void FifoPlayer::WriteAllMemoryUpdates()
@@ -5,16 +5,18 @@

 #include <functional>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>

+#include "Common/Assert.h"
 #include "Core/FifoPlayer/FifoDataFile.h"
-#include "Core/FifoPlayer/FifoPlaybackAnalyzer.h"
 #include "Core/PowerPC/CPUCoreBase.h"
+#include "VideoCommon/CPMemory.h"
+#include "VideoCommon/OpcodeDecoding.h"

 class FifoDataFile;
 struct MemoryUpdate;
-struct AnalyzedFrameInfo;

 namespace CPU
 {
@@ -43,16 +45,46 @@ enum class State;
 //    8. The output of fifoplayer would be wrong.

 // To keep compatibility with old fifologs, we have this flag which signals texture cache to not
-// bother
-// hashing the memory and just assume the hash matched.
+// bother hashing the memory and just assume the hash matched.
 // At a later point proper efb copy support should be added to fiforecorder and this flag will
-// change
-// based on the version of the .dff file, but until then it will always be true when a fifolog is
-// playing.
+// change based on the version of the .dff file, but until then it will always be true when a
+// fifolog is playing.

 // Shitty global to fix a shitty problem
 extern bool IsPlayingBackFifologWithBrokenEFBCopies;

+enum class FramePartType
+{
+  Commands,
+  PrimitiveData,
+  EFBCopy,
+};
+
+struct FramePart
+{
+  constexpr FramePart(FramePartType type, u32 start, u32 end, const CPState& cpmem)
+      : m_type(type), m_start(start), m_end(end), m_cpmem(cpmem)
+  {
+  }
+
+  const FramePartType m_type;
+  const u32 m_start;
+  const u32 m_end;
+  const CPState m_cpmem;
+};
+
+struct AnalyzedFrameInfo
+{
+  std::vector<FramePart> parts;
+  Common::EnumMap<u32, FramePartType::EFBCopy> part_type_counts;
+
+  void AddPart(FramePartType type, u32 start, u32 end, const CPState& cpmem)
+  {
+    parts.emplace_back(type, start, end, cpmem);
+    part_type_counts[type]++;
+  }
+};
+
 class FifoPlayer
 {
 public:
@@ -102,14 +134,12 @@ public:

 private:
  class CPUCore;
-
  FifoPlayer();

  CPU::State AdvanceFrame();

  void WriteFrame(const FifoFrameInfo& frame, const AnalyzedFrameInfo& info);
-  void WriteFramePart(u32 dataStart, u32 dataEnd, u32& nextMemUpdate, const FifoFrameInfo& frame,
-                      const AnalyzedFrameInfo& info);
+  void WriteFramePart(const FramePart& part, u32* next_mem_update, const FifoFrameInfo& frame);

  void WriteAllMemoryUpdates();
  void WriteMemory(const MemoryUpdate& memUpdate);
@@ -1,103 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "Core/FifoPlayer/FifoRecordAnalyzer.h"
-
-#include <algorithm>
-
-#include "Common/MsgHandler.h"
-#include "Core/FifoPlayer/FifoAnalyzer.h"
-#include "Core/FifoPlayer/FifoRecorder.h"
-#include "Core/HW/Memmap.h"
-
-using namespace FifoAnalyzer;
-
-void FifoRecordAnalyzer::Initialize(const u32* cpMem)
-{
-  s_DrawingObject = false;
-
-  FifoAnalyzer::LoadCPReg(VCD_LO, cpMem[VCD_LO], s_CpMem);
-  FifoAnalyzer::LoadCPReg(VCD_HI, cpMem[VCD_HI], s_CpMem);
-  for (u32 i = 0; i < CP_NUM_VAT_REG; ++i)
-    FifoAnalyzer::LoadCPReg(CP_VAT_REG_A + i, cpMem[CP_VAT_REG_A + i], s_CpMem);
-
-  const u32* const bases_start = cpMem + ARRAY_BASE;
-  const u32* const bases_end = bases_start + s_CpMem.arrayBases.size();
-  std::copy(bases_start, bases_end, s_CpMem.arrayBases.begin());
-
-  const u32* const strides_start = cpMem + ARRAY_STRIDE;
-  const u32* const strides_end = strides_start + s_CpMem.arrayStrides.size();
-  std::copy(strides_start, strides_end, s_CpMem.arrayStrides.begin());
-}
-
-void FifoRecordAnalyzer::ProcessLoadIndexedXf(u32 val, int array)
-{
-  int index = val >> 16;
-  int size = ((val >> 12) & 0xF) + 1;
-
-  u32 address = s_CpMem.arrayBases[array] + s_CpMem.arrayStrides[array] * index;
-
-  FifoRecorder::GetInstance().UseMemory(address, size * 4, MemoryUpdate::XF_DATA);
-}
-
-void FifoRecordAnalyzer::WriteVertexArray(int arrayIndex, const u8* vertexData, int vertexSize,
-                                          int numVertices)
-{
-  // Skip if not indexed array
-  VertexComponentFormat arrayType;
-  if (arrayIndex == ARRAY_POSITION)
-    arrayType = s_CpMem.vtxDesc.low.Position;
-  else if (arrayIndex == ARRAY_NORMAL)
-    arrayType = s_CpMem.vtxDesc.low.Normal;
-  else if (arrayIndex >= ARRAY_COLOR0 && arrayIndex < ARRAY_COLOR0 + NUM_COLOR_ARRAYS)
-    arrayType = s_CpMem.vtxDesc.low.Color[arrayIndex - ARRAY_COLOR0];
-  else if (arrayIndex >= ARRAY_TEXCOORD0 && arrayIndex < ARRAY_TEXCOORD0 + NUM_TEXCOORD_ARRAYS)
-    arrayType = s_CpMem.vtxDesc.high.TexCoord[arrayIndex - ARRAY_TEXCOORD0];
-  else
-  {
-    PanicAlertFmt("Invalid arrayIndex {}", arrayIndex);
-    return;
-  }
-
-  if (!IsIndexed(arrayType))
-    return;
-
-  int maxIndex = 0;
-
-  // Determine min and max indices
-  if (arrayType == VertexComponentFormat::Index8)
-  {
-    for (int i = 0; i < numVertices; ++i)
-    {
-      int index = *vertexData;
-      vertexData += vertexSize;
-
-      // 0xff skips the vertex
-      if (index != 0xff)
-      {
-        if (index > maxIndex)
-          maxIndex = index;
-      }
-    }
-  }
-  else
-  {
-    for (int i = 0; i < numVertices; ++i)
-    {
-      int index = Common::swap16(vertexData);
-      vertexData += vertexSize;
-
-      // 0xffff skips the vertex
-      if (index != 0xffff)
-      {
-        if (index > maxIndex)
-          maxIndex = index;
-      }
-    }
-  }
-
-  u32 arrayStart = s_CpMem.arrayBases[arrayIndex];
-  u32 arraySize = s_CpMem.arrayStrides[arrayIndex] * (maxIndex + 1);
-
-  FifoRecorder::GetInstance().UseMemory(arrayStart, arraySize, MemoryUpdate::VERTEX_STREAM);
-}
@@ -1,15 +0,0 @@
-// Copyright 2011 Dolphin Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "Common/CommonTypes.h"
-
-namespace FifoRecordAnalyzer
-{
-// Must call this before analyzing Fifo commands with FifoAnalyzer::AnalyzeCommand()
-void Initialize(const u32* cpMem);
-
-void ProcessLoadIndexedXf(u32 val, int array);
-void WriteVertexArray(int arrayIndex, const u8* vertexData, int vertexSize, int numVertices);
-}  // namespace FifoRecordAnalyzer
@@ -6,13 +6,168 @@
 #include <algorithm>
 #include <cstring>

+#include "Common/Logging/Log.h"
 #include "Common/MsgHandler.h"
 #include "Common/Thread.h"
+
 #include "Core/ConfigManager.h"
-#include "Core/FifoPlayer/FifoAnalyzer.h"
-#include "Core/FifoPlayer/FifoRecordAnalyzer.h"
 #include "Core/HW/Memmap.h"

+#include "VideoCommon/OpcodeDecoding.h"
+#include "VideoCommon/XFStructs.h"
+
+class FifoRecorder::FifoRecordAnalyzer : public OpcodeDecoder::Callback
+{
+public:
+  explicit FifoRecordAnalyzer(FifoRecorder* owner) : m_owner(owner) {}
+  explicit FifoRecordAnalyzer(FifoRecorder* owner, const u32* cpmem)
+      : m_owner(owner), m_cpmem(cpmem)
+  {
+  }
+
+  OPCODE_CALLBACK(void OnXF(u16 address, u8 count, const u8* data)) {}
+  OPCODE_CALLBACK(void OnCP(u8 command, u32 value)) { GetCPState().LoadCPReg(command, value); }
+  OPCODE_CALLBACK(void OnBP(u8 command, u32 value)) {}
+  OPCODE_CALLBACK(void OnIndexedLoad(CPArray array, u32 index, u16 address, u8 size));
+  OPCODE_CALLBACK(void OnPrimitiveCommand(OpcodeDecoder::Primitive primitive, u8 vat,
+                                          u32 vertex_size, u16 num_vertices,
+                                          const u8* vertex_data));
+  OPCODE_CALLBACK(void OnDisplayList(u32 address, u32 size))
+  {
+    WARN_LOG_FMT(VIDEO,
+                 "Unhandled display list call {:08x} {:08x}; should have been inlined earlier",
+                 address, size);
+  }
+  OPCODE_CALLBACK(void OnNop(u32 count)) {}
+  OPCODE_CALLBACK(void OnUnknown(u8 opcode, const u8* data)) {}
+
+  OPCODE_CALLBACK(void OnCommand(const u8* data, u32 size)) {}
+
+  OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
+
+private:
+  void ProcessVertexComponent(CPArray array_index, VertexComponentFormat array_type,
+                              u32 component_offset, u32 vertex_size, u16 num_vertices,
+                              const u8* vertex_data);
+
+  FifoRecorder* const m_owner;
+  CPState m_cpmem;
+};
+
+void FifoRecorder::FifoRecordAnalyzer::OnIndexedLoad(CPArray array, u32 index, u16 address, u8 size)
+{
+  const u32 load_address = m_cpmem.array_bases[array] + m_cpmem.array_strides[array] * index;
+
+  m_owner->UseMemory(load_address, size * sizeof(u32), MemoryUpdate::XF_DATA);
+}
+
+// TODO: The following code is copied with modifications from VertexLoaderBase.
+// Surely there's a better solution?
+#include "VideoCommon/VertexLoader_Color.h"
+#include "VideoCommon/VertexLoader_Normal.h"
+#include "VideoCommon/VertexLoader_Position.h"
+#include "VideoCommon/VertexLoader_TextCoord.h"
+
+void FifoRecorder::FifoRecordAnalyzer::OnPrimitiveCommand(OpcodeDecoder::Primitive primitive,
+                                                          u8 vat, u32 vertex_size, u16 num_vertices,
+                                                          const u8* vertex_data)
+{
+  const auto& vtx_desc = m_cpmem.vtx_desc;
+  const auto& vtx_attr = m_cpmem.vtx_attr[vat];
+
+  u32 offset = 0;
+
+  if (vtx_desc.low.PosMatIdx)
+    offset++;
+  for (auto texmtxidx : vtx_desc.low.TexMatIdx)
+  {
+    if (texmtxidx)
+      offset++;
+  }
+  const u32 pos_size = VertexLoader_Position::GetSize(vtx_desc.low.Position, vtx_attr.g0.PosFormat,
+                                                      vtx_attr.g0.PosElements);
+  ProcessVertexComponent(CPArray::Position, vtx_desc.low.Position, offset, vertex_size,
+                         num_vertices, vertex_data);
+  offset += pos_size;
+
+  const u32 norm_size =
+      VertexLoader_Normal::GetSize(vtx_desc.low.Normal, vtx_attr.g0.NormalFormat,
+                                   vtx_attr.g0.NormalElements, vtx_attr.g0.NormalIndex3);
+  ProcessVertexComponent(CPArray::Normal, vtx_desc.low.Position, offset, vertex_size, num_vertices,
+                         vertex_data);
+  offset += norm_size;
+
+  for (u32 i = 0; i < vtx_desc.low.Color.Size(); i++)
+  {
+    const u32 color_size =
+        VertexLoader_Color::GetSize(vtx_desc.low.Color[i], vtx_attr.GetColorFormat(i));
+    ProcessVertexComponent(CPArray::Color0 + i, vtx_desc.low.Position, offset, vertex_size,
+                           num_vertices, vertex_data);
+    offset += color_size;
+  }
+  for (u32 i = 0; i < vtx_desc.high.TexCoord.Size(); i++)
+  {
+    const u32 tc_size = VertexLoader_TextCoord::GetSize(
+        vtx_desc.high.TexCoord[i], vtx_attr.GetTexFormat(i), vtx_attr.GetTexElements(i));
+    ProcessVertexComponent(CPArray::TexCoord0 + i, vtx_desc.low.Position, offset, vertex_size,
+                           num_vertices, vertex_data);
+    offset += tc_size;
+  }
+
+  ASSERT(offset == vertex_size);
+}
+
+// If a component is indexed, the array it indexes into for data must be saved.
+void FifoRecorder::FifoRecordAnalyzer::ProcessVertexComponent(CPArray array_index,
+                                                              VertexComponentFormat array_type,
+                                                              u32 component_offset, u32 vertex_size,
+                                                              u16 num_vertices,
+                                                              const u8* vertex_data)
+{
+  // Skip if not indexed array
+  if (!IsIndexed(array_type))
+    return;
+
+  u16 max_index = 0;
+
+  // Determine min and max indices
+  if (array_type == VertexComponentFormat::Index8)
+  {
+    for (u16 vertex_num = 0; vertex_num < num_vertices; vertex_num++)
+    {
+      const u8 index = vertex_data[component_offset];
+      vertex_data += vertex_size;
+
+      // 0xff skips the vertex
+      if (index != 0xff)
+      {
+        if (index > max_index)
+          max_index = index;
+      }
+    }
+  }
+  else
+  {
+    for (u16 vertex_num = 0; vertex_num < num_vertices; vertex_num++)
+    {
+      const u16 index = Common::swap16(&vertex_data[component_offset]);
+      vertex_data += vertex_size;
+
+      // 0xffff skips the vertex
+      if (index != 0xffff)
+      {
+        if (index > max_index)
+          max_index = index;
+      }
+    }
+  }
+
+  const u32 array_start = m_cpmem.array_bases[array_index];
+  const u32 array_size = m_cpmem.array_strides[array_index] * (max_index + 1);
+
+  m_owner->UseMemory(array_start, array_size, MemoryUpdate::VERTEX_STREAM);
+}
+
 static FifoRecorder instance;

 FifoRecorder::FifoRecorder() = default;
@@ -76,7 +231,7 @@ void FifoRecorder::WriteGPCommand(const u8* data, u32 size)
  {
    // Assumes data contains all information for the command
    // Calls FifoRecorder::UseMemory
-    const u32 analyzed_size = FifoAnalyzer::AnalyzeCommand(data, FifoAnalyzer::DecodeMode::Record);
+    const u32 analyzed_size = OpcodeDecoder::RunCommand(data, size, *m_record_analyzer);

    // Make sure FifoPlayer's command analyzer agrees about the size of the command.
    if (analyzed_size != size)
@@ -211,7 +366,7 @@ void FifoRecorder::SetVideoMemory(const u32* bpMem, const u32* cpMem, const u32*
    memcpy(m_File->GetTexMem(), texMem, FifoDataFile::TEX_MEM_SIZE);
  }

-  FifoRecordAnalyzer::Initialize(cpMem);
+  m_record_analyzer = std::make_unique<FifoRecordAnalyzer>(this, cpMem);
 }

 bool FifoRecorder::IsRecording() const
@@ -8,6 +8,7 @@
 #include <mutex>
 #include <vector>

+#include "Common/Assert.h"
 #include "Core/FifoPlayer/FifoDataFile.h"

 class FifoRecorder
@@ -47,6 +48,8 @@ public:
  static FifoRecorder& GetInstance();

 private:
+  class FifoRecordAnalyzer;
+
  // Accessed from both GUI and video threads

  std::recursive_mutex m_mutex;
@@ -65,6 +68,7 @@ private:
  bool m_SkipFutureData = true;
  bool m_FrameEnded = false;
  FifoFrameInfo m_CurrentFrame;
+  std::unique_ptr<FifoRecordAnalyzer> m_record_analyzer;
  std::vector<u8> m_FifoData;
  std::vector<u8> m_Ram;
  std::vector<u8> m_ExRam;
@@ -217,11 +217,8 @@
    <ClInclude Include="Core\DSP\Jit\x64\DSPJitTables.h" />
    <ClInclude Include="Core\DSP\LabelMap.h" />
    <ClInclude Include="Core\DSPEmulator.h" />
-    <ClInclude Include="Core\FifoPlayer\FifoAnalyzer.h" />
    <ClInclude Include="Core\FifoPlayer\FifoDataFile.h" />
-    <ClInclude Include="Core\FifoPlayer\FifoPlaybackAnalyzer.h" />
    <ClInclude Include="Core\FifoPlayer\FifoPlayer.h" />
-    <ClInclude Include="Core\FifoPlayer\FifoRecordAnalyzer.h" />
    <ClInclude Include="Core\FifoPlayer\FifoRecorder.h" />
    <ClInclude Include="Core\FreeLookConfig.h" />
    <ClInclude Include="Core\FreeLookManager.h" />
@@ -815,11 +812,8 @@
    <ClCompile Include="Core\DSP\Jit\x64\DSPJitUtil.cpp" />
    <ClCompile Include="Core\DSP\LabelMap.cpp" />
    <ClCompile Include="Core\DSPEmulator.cpp" />
-    <ClCompile Include="Core\FifoPlayer\FifoAnalyzer.cpp" />
    <ClCompile Include="Core\FifoPlayer\FifoDataFile.cpp" />
-    <ClCompile Include="Core\FifoPlayer\FifoPlaybackAnalyzer.cpp" />
    <ClCompile Include="Core\FifoPlayer\FifoPlayer.cpp" />
-    <ClCompile Include="Core\FifoPlayer\FifoRecordAnalyzer.cpp" />
    <ClCompile Include="Core\FifoPlayer\FifoRecorder.cpp" />
    <ClCompile Include="Core\FreeLookConfig.cpp" />
    <ClCompile Include="Core\FreeLookManager.cpp" />
@@ -58,15 +58,19 @@ private:

  struct SearchResult
  {
-    constexpr SearchResult(u32 frame, u32 object, u32 cmd)
-        : m_frame(frame), m_object(object), m_cmd(cmd)
+    constexpr SearchResult(u32 frame, u32 object_idx, u32 cmd)
+        : m_frame(frame), m_object_idx(object_idx), m_cmd(cmd)
    {
    }
    const u32 m_frame;
-    const u32 m_object;
+    // Index in tree view.  Does not correspond with object numbers or part numbers.
+    const u32 m_object_idx;
    const u32 m_cmd;
  };

+  // Offsets from the start of the first part in an object for each command within the currently
+  // selected object.
  std::vector<int> m_object_data_offsets;
+
  std::vector<SearchResult> m_search_results;
 };
@@ -21,7 +21,6 @@

 #include "Core/Core.h"
 #include "Core/FifoPlayer/FifoDataFile.h"
-#include "Core/FifoPlayer/FifoPlaybackAnalyzer.h"
 #include "Core/FifoPlayer/FifoPlayer.h"
 #include "Core/FifoPlayer/FifoRecorder.h"

@@ -151,18 +150,18 @@ void FIFOPlayerWindow::CreateWidgets()
  layout->addWidget(recording_group);
  layout->addWidget(m_button_box);

-  QWidget* main_widget = new QWidget(this);
-  main_widget->setLayout(layout);
+  m_main_widget = new QWidget(this);
+  m_main_widget->setLayout(layout);

-  auto* tab_widget = new QTabWidget(this);
+  m_tab_widget = new QTabWidget(this);

  m_analyzer = new FIFOAnalyzer;

-  tab_widget->addTab(main_widget, tr("Play / Record"));
-  tab_widget->addTab(m_analyzer, tr("Analyze"));
+  m_tab_widget->addTab(m_main_widget, tr("Play / Record"));
+  m_tab_widget->addTab(m_analyzer, tr("Analyze"));

  auto* tab_layout = new QVBoxLayout;
-  tab_layout->addWidget(tab_widget);
+  tab_layout->addWidget(m_tab_widget);

  setLayout(tab_layout);
 }
@@ -251,6 +250,8 @@ void FIFOPlayerWindow::OnEmulationStopped()
    StopRecording();

  UpdateControls();
+  // When emulation stops, switch away from the analyzer tab, as it no longer shows anything useful
+  m_tab_widget->setCurrentWidget(m_main_widget);
  m_analyzer->Update();
 }

@@ -12,6 +12,7 @@ class QDialogButtonBox;
 class QLabel;
 class QPushButton;
 class QSpinBox;
+class QTabWidget;
 class FIFOAnalyzer;

 class FIFOPlayerWindow : public QWidget
@@ -64,6 +65,9 @@ private:
  QCheckBox* m_early_memory_updates;
  QDialogButtonBox* m_button_box;

+  QWidget* m_main_widget;
+  QTabWidget* m_tab_widget;
+
  FIFOAnalyzer* m_analyzer;
  Core::State m_emu_state = Core::State::Uninitialized;
 };
@@ -12,7 +12,6 @@ set_target_properties(dolphin-tool PROPERTIES OUTPUT_NAME dolphin-tool)

 target_link_libraries(dolphin-tool
 PRIVATE
-  core
  discio
  videocommon
  cpp-optparse
@@ -3,6 +3,8 @@

 #include <array>

+#include "Common/EnumMap.h"
+
 #include "VideoBackends/D3D/D3DBase.h"
 #include "VideoBackends/D3D/D3DRender.h"
 #include "VideoBackends/D3D/D3DState.h"
@@ -20,55 +22,75 @@ Renderer::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
  return std::make_unique<D3DVertexFormat>(vtx_decl);
 }

-static const DXGI_FORMAT d3d_format_lookup[5 * 4 * 2] = {
-    // float formats
-    DXGI_FORMAT_R8_UNORM,
-    DXGI_FORMAT_R8_SNORM,
-    DXGI_FORMAT_R16_UNORM,
-    DXGI_FORMAT_R16_SNORM,
-    DXGI_FORMAT_R32_FLOAT,
-    DXGI_FORMAT_R8G8_UNORM,
-    DXGI_FORMAT_R8G8_SNORM,
-    DXGI_FORMAT_R16G16_UNORM,
-    DXGI_FORMAT_R16G16_SNORM,
-    DXGI_FORMAT_R32G32_FLOAT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R32G32B32_FLOAT,
-    DXGI_FORMAT_R8G8B8A8_UNORM,
-    DXGI_FORMAT_R8G8B8A8_SNORM,
-    DXGI_FORMAT_R16G16B16A16_UNORM,
-    DXGI_FORMAT_R16G16B16A16_SNORM,
-    DXGI_FORMAT_R32G32B32A32_FLOAT,
-
-    // integer formats
-    DXGI_FORMAT_R8_UINT,
-    DXGI_FORMAT_R8_SINT,
-    DXGI_FORMAT_R16_UINT,
-    DXGI_FORMAT_R16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R8G8_UINT,
-    DXGI_FORMAT_R8G8_SINT,
-    DXGI_FORMAT_R16G16_UINT,
-    DXGI_FORMAT_R16G16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_UNKNOWN,
-    DXGI_FORMAT_R8G8B8A8_UINT,
-    DXGI_FORMAT_R8G8B8A8_SINT,
-    DXGI_FORMAT_R16G16B16A16_UINT,
-    DXGI_FORMAT_R16G16B16A16_SINT,
-    DXGI_FORMAT_UNKNOWN,
-};
-
-DXGI_FORMAT VarToD3D(VarType t, int size, bool integer)
+DXGI_FORMAT VarToD3D(ComponentFormat t, int size, bool integer)
 {
-  DXGI_FORMAT retval = d3d_format_lookup[(int)t + 5 * (size - 1) + 5 * 4 * (int)integer];
+  using FormatMap = Common::EnumMap<DXGI_FORMAT, ComponentFormat::Float>;
+  static constexpr auto f = [](FormatMap a) { return a; };  // Deduction helper
+
+  static constexpr std::array<FormatMap, 4> d3d_float_format_lookup = {
+      f({
+          DXGI_FORMAT_R8_UNORM,
+          DXGI_FORMAT_R8_SNORM,
+          DXGI_FORMAT_R16_UNORM,
+          DXGI_FORMAT_R16_SNORM,
+          DXGI_FORMAT_R32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_R8G8_UNORM,
+          DXGI_FORMAT_R8G8_SNORM,
+          DXGI_FORMAT_R16G16_UNORM,
+          DXGI_FORMAT_R16G16_SNORM,
+          DXGI_FORMAT_R32G32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_R32G32B32_FLOAT,
+      }),
+      f({
+          DXGI_FORMAT_R8G8B8A8_UNORM,
+          DXGI_FORMAT_R8G8B8A8_SNORM,
+          DXGI_FORMAT_R16G16B16A16_UNORM,
+          DXGI_FORMAT_R16G16B16A16_SNORM,
+          DXGI_FORMAT_R32G32B32A32_FLOAT,
+      }),
+  };
+
+  static constexpr std::array<FormatMap, 4> d3d_integer_format_lookup = {
+      f({
+          DXGI_FORMAT_R8_UINT,
+          DXGI_FORMAT_R8_SINT,
+          DXGI_FORMAT_R16_UINT,
+          DXGI_FORMAT_R16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_R8G8_UINT,
+          DXGI_FORMAT_R8G8_SINT,
+          DXGI_FORMAT_R16G16_UINT,
+          DXGI_FORMAT_R16G16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+      f({
+          DXGI_FORMAT_R8G8B8A8_UINT,
+          DXGI_FORMAT_R8G8B8A8_SINT,
+          DXGI_FORMAT_R16G16B16A16_UINT,
+          DXGI_FORMAT_R16G16B16A16_SINT,
+          DXGI_FORMAT_UNKNOWN,
+      }),
+  };
+
+  DXGI_FORMAT retval =
+      integer ? d3d_integer_format_lookup[size - 1][t] : d3d_float_format_lookup[size - 1][t];
  if (retval == DXGI_FORMAT_UNKNOWN)
  {
    PanicAlertFmt("VarToD3D: Invalid type/size combo {}, {}, {}", t, size, integer);
@@ -4,39 +4,43 @@
 #include "VideoBackends/D3D12/DX12VertexFormat.h"

 #include "Common/Assert.h"
+#include "Common/EnumMap.h"

 #include "VideoCommon/VertexLoaderManager.h"
 #include "VideoCommon/VertexShaderGen.h"

 namespace DX12
 {
-static DXGI_FORMAT VarToDXGIFormat(VarType t, u32 components, bool integer)
+static DXGI_FORMAT VarToDXGIFormat(ComponentFormat t, u32 components, bool integer)
 {
+  using ComponentArray = std::array<DXGI_FORMAT, 4>;
+  static constexpr auto f = [](ComponentArray a) { return a; };  // Deduction helper
+
  // NOTE: 3-component formats are not valid.
-  static const DXGI_FORMAT float_type_lookup[][4] = {
-      {DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
-       DXGI_FORMAT_R8G8B8A8_UNORM},  // VAR_UNSIGNED_BYTE
-      {DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM,
-       DXGI_FORMAT_R8G8B8A8_SNORM},  // VAR_BYTE
-      {DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM,
-       DXGI_FORMAT_R16G16B16A16_UNORM},  // VAR_UNSIGNED_SHORT
-      {DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_R16G16B16A16_SNORM,
-       DXGI_FORMAT_R16G16B16A16_SNORM},  // VAR_SHORT
-      {DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
-       DXGI_FORMAT_R32G32B32A32_FLOAT}  // VAR_FLOAT
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> float_type_lookup = {
+      f({DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
+         DXGI_FORMAT_R8G8B8A8_UNORM}),  // UByte
+      f({DXGI_FORMAT_R8_SNORM, DXGI_FORMAT_R8G8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM,
+         DXGI_FORMAT_R8G8B8A8_SNORM}),  // Byte
+      f({DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM,
+         DXGI_FORMAT_R16G16B16A16_UNORM}),  // UShort
+      f({DXGI_FORMAT_R16_SNORM, DXGI_FORMAT_R16G16_SNORM, DXGI_FORMAT_R16G16B16A16_SNORM,
+         DXGI_FORMAT_R16G16B16A16_SNORM}),  // Short
+      f({DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
+         DXGI_FORMAT_R32G32B32A32_FLOAT}),  // Float
  };

-  static const DXGI_FORMAT integer_type_lookup[][4] = {
-      {DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8B8A8_UINT,
-       DXGI_FORMAT_R8G8B8A8_UINT},  // VAR_UNSIGNED_BYTE
-      {DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8B8A8_SINT,
-       DXGI_FORMAT_R8G8B8A8_SINT},  // VAR_BYTE
-      {DXGI_FORMAT_R16_UINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16B16A16_UINT,
-       DXGI_FORMAT_R16G16B16A16_UINT},  // VAR_UNSIGNED_SHORT
-      {DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16B16A16_SINT,
-       DXGI_FORMAT_R16G16B16A16_SINT},  // VAR_SHORT
-      {DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
-       DXGI_FORMAT_R32G32B32A32_FLOAT}  // VAR_FLOAT
+  static constexpr Common::EnumMap<ComponentArray, ComponentFormat::Float> integer_type_lookup = {
+      f({DXGI_FORMAT_R8_UINT, DXGI_FORMAT_R8G8_UINT, DXGI_FORMAT_R8G8B8A8_UINT,
+         DXGI_FORMAT_R8G8B8A8_UINT}),  // UByte
+      f({DXGI_FORMAT_R8_SINT, DXGI_FORMAT_R8G8_SINT, DXGI_FORMAT_R8G8B8A8_SINT,
+         DXGI_FORMAT_R8G8B8A8_SINT}),  // Byte
+      f({DXGI_FORMAT_R16_UINT, DXGI_FORMAT_R16G16_UINT, DXGI_FORMAT_R16G16B16A16_UINT,
+         DXGI_FORMAT_R16G16B16A16_UINT}),  // UShort
+      f({DXGI_FORMAT_R16_SINT, DXGI_FORMAT_R16G16_SINT, DXGI_FORMAT_R16G16B16A16_SINT,
+         DXGI_FORMAT_R16G16B16A16_SINT}),  // Short
+      f({DXGI_FORMAT_R32_FLOAT, DXGI_FORMAT_R32G32_FLOAT, DXGI_FORMAT_R32G32B32_FLOAT,
+         DXGI_FORMAT_R32G32B32A32_FLOAT}),  // Float
  };

  ASSERT(components > 0 && components <= 4);
--- a/Show More
+++ b/Show More