Video: Clearly separate Texture and EFB Copy formats

Improve bookkeeping around formats. Hopefully make code less confusing.

- Rename TlutFormat -> TLUTFormat to follow conventions.
- Use enum classes to prevent using a Texture format where an EFB Copy format
  is expected or vice-versa.
- Use common EFBCopyFormat names regardless of depth and YUV configurations.

3 files changed, 461 insertions, 450 deletions

diff --git a/Source/Core/VideoBackends/Software/SWmain.cpp b/Source/Core/VideoBackends/Software/SWmain.cpp
index 910de9697d..d1f9ac3bb0 100644
--- a/Source/Core/VideoBackends/Software/SWmain.cpp
+++ b/Source/Core/VideoBackends/Software/SWmain.cpp
@@ -50,13 +50,13 @@ class TextureCache : public TextureCacheBase
 public:
   bool CompileShaders() override { return true; }
   void DeleteShaders() override {}
-  void ConvertTexture(TCacheEntry* entry, TCacheEntry* unconverted, void* palette,
-                      TlutFormat format) override
+  void ConvertTexture(TCacheEntry* entry, TCacheEntry* unconverted, const void* palette,
+                      TLUTFormat format) override
   {
   }
-  void CopyEFB(u8* dst, const EFBCopyFormat& format, u32 native_width, u32 bytes_per_row,
-               u32 num_blocks_y, u32 memory_stride, bool is_depth_copy,
-               const EFBRectangle& src_rect, bool scale_by_half) override
+  void CopyEFB(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
+               u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
+               bool scale_by_half) override
   {
     EfbCopy::CopyEfb();
   }
diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp
index 92dffe1b4b..6181d56dd4 100644
--- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp
+++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp
@@ -263,7 +263,7 @@ static void SetSpans(int sBlkSize, int tBlkSize, s32* tSpan, s32* sBlkSpan, s32*
   dstBlockStart += writeStride;                                                                    \
   }
 
-static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
+static void EncodeRGBA6(u8* dst, const u8* src, EFBCopyFormat format, bool yuv)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -273,62 +273,121 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_I4:
+  case EFBCopyFormat::R4:
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      RGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst = RGB8_to_I(r, g, b) & 0xf0;
+      ENCODE_LOOP_BLOCKS
+      {
+        RGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst = RGB8_to_I(r, g, b) & 0xf0;
 
-      RGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst |= RGB8_to_I(r, g, b) >> 4;
-      dst++;
+        RGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst |= RGB8_to_I(r, g, b) >> 4;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        u32 srcColor = *(u32*)src;
+        src += readStride;
+        *dst = (srcColor >> 16) & 0xf0;
+
+        srcColor = *(u32*)src;
+        src += readStride;
+        *dst |= (srcColor >> 20) & 0x0f;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_I8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      RGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst++ = RGB8_to_I(r, g, b);
+      ENCODE_LOOP_BLOCKS
+      {
+        RGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst++ = RGB8_to_I(r, g, b);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        u32 srcColor = *(u32*)src;
+        *dst++ = Convert6To8((srcColor >> 18) & 0x3f);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA4:
+  case EFBCopyFormat::RA4:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      RGBA_to_RGBA8(src, &r, &g, &b, &a);
-      src += readStride;
-      *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4);
+      ENCODE_LOOP_BLOCKS
+      {
+        RGBA_to_RGBA8(src, &r, &g, &b, &a);
+        src += readStride;
+        *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        u32 srcColor = *(u32*)src;
+        src += readStride;
+        *dst++ = ((srcColor << 2) & 0xf0) | ((srcColor >> 20) & 0x0f);
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA8:
+  case EFBCopyFormat::RA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      RGBA_to_RGBA8(src, &r, &g, &b, &a);
-      src += readStride;
-      *dst++ = a;
-      *dst++ = RGB8_to_I(r, g, b);
+      ENCODE_LOOP_BLOCKS
+      {
+        RGBA_to_RGBA8(src, &r, &g, &b, &a);
+        src += readStride;
+        *dst++ = a;
+        *dst++ = RGB8_to_I(r, g, b);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        u32 srcColor = *(u32*)src;
+        src += readStride;
+        *dst++ = Convert6To8(srcColor & 0x3f);
+        *dst++ = Convert6To8((srcColor >> 18) & 0x3f);
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB565:
+  case EFBCopyFormat::RGB565:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -344,7 +403,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB5A3:
+  case EFBCopyFormat::RGB5A3:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -367,7 +426,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGBA8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -379,50 +438,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_R4:
-    SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
-    {
-      u32 srcColor = *(u32*)src;
-      src += readStride;
-      *dst = (srcColor >> 16) & 0xf0;
-
-      srcColor = *(u32*)src;
-      src += readStride;
-      *dst |= (srcColor >> 20) & 0x0f;
-      dst++;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA4:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      u32 srcColor = *(u32*)src;
-      src += readStride;
-      *dst++ = ((srcColor << 2) & 0xf0) | ((srcColor >> 20) & 0x0f);
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA8:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      u32 srcColor = *(u32*)src;
-      src += readStride;
-      *dst++ = Convert6To8(srcColor & 0x3f);
-      *dst++ = Convert6To8((srcColor >> 18) & 0x3f);
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_A8:
+  case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -434,19 +450,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_R8:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      u32 srcColor = *(u32*)src;
-      *dst++ = Convert6To8((srcColor >> 18) & 0x3f);
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_G8:
+  case EFBCopyFormat::G8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -458,7 +462,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_B8:
+  case EFBCopyFormat::B8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -470,7 +474,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_RG8:
+  case EFBCopyFormat::RG8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -483,7 +487,7 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_GB8:
+  case EFBCopyFormat::GB8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -497,12 +501,12 @@ static void EncodeRGBA6(u8* dst, const u8* src, u32 format)
     break;
 
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
 
-static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
+static void EncodeRGBA6halfscale(u8* dst, const u8* src, EFBCopyFormat format, bool yuv)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -512,62 +516,121 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_I4:
+  case EFBCopyFormat::R4:
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst = RGB8_to_I(r, g, b) & 0xf0;
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst = RGB8_to_I(r, g, b) & 0xf0;
 
-      BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst |= RGB8_to_I(r, g, b) >> 4;
-      dst++;
+        BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst |= RGB8_to_I(r, g, b) >> 4;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_x8(src, &r, 18);
+        src += readStride;
+        *dst = r & 0xf0;
+
+        BoxfilterRGBA_to_x8(src, &r, 18);
+        src += readStride;
+        *dst |= r >> 4;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_I8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
-      src += readStride;
-      *dst++ = RGB8_to_I(r, g, b);
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_RGB8(src, &r, &g, &b);
+        src += readStride;
+        *dst++ = RGB8_to_I(r, g, b);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_x8(src, &r, 18);
+        *dst++ = r;
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA4:
+  case EFBCopyFormat::RA4:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a);
-      src += readStride;
-      *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4);
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a);
+        src += readStride;
+        *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0);
+        src += readStride;
+        *dst++ = (a & 0xf0) | (r >> 4);
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA8:
+  case EFBCopyFormat::RA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a);
-      src += readStride;
-      *dst++ = a;
-      *dst++ = RGB8_to_I(r, g, b);
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a);
+        src += readStride;
+        *dst++ = a;
+        *dst++ = RGB8_to_I(r, g, b);
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0);
+        src += readStride;
+        *dst++ = a;
+        *dst++ = r;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB565:
+  case EFBCopyFormat::RGB565:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -582,7 +645,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB5A3:
+  case EFBCopyFormat::RGB5A3:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -602,7 +665,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGBA8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -614,50 +677,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_R4:
-    SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGBA_to_x8(src, &r, 18);
-      src += readStride;
-      *dst = r & 0xf0;
-
-      BoxfilterRGBA_to_x8(src, &r, 18);
-      src += readStride;
-      *dst |= r >> 4;
-      dst++;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA4:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0);
-      src += readStride;
-      *dst++ = (a & 0xf0) | (r >> 4);
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA8:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0);
-      src += readStride;
-      *dst++ = a;
-      *dst++ = r;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_A8:
+  case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -669,19 +689,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_R8:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGBA_to_x8(src, &r, 18);
-      *dst++ = r;
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_G8:
+  case EFBCopyFormat::G8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -693,7 +701,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_B8:
+  case EFBCopyFormat::B8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -705,7 +713,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_RG8:
+  case EFBCopyFormat::RG8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -718,7 +726,7 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_GB8:
+  case EFBCopyFormat::GB8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -732,12 +740,12 @@ static void EncodeRGBA6halfscale(u8* dst, const u8* src, u32 format)
     break;
 
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
 
-static void EncodeRGB8(u8* dst, const u8* src, u32 format)
+static void EncodeRGB8(u8* dst, const u8* src, EFBCopyFormat format, bool yuv)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -746,58 +754,113 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_I4:
+  case EFBCopyFormat::R4:
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      *dst = RGB8_to_I(src[2], src[1], src[0]) & 0xf0;
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst = RGB8_to_I(src[2], src[1], src[0]) & 0xf0;
+        src += readStride;
 
-      *dst |= RGB8_to_I(src[2], src[1], src[0]) >> 4;
-      src += readStride;
-      dst++;
+        *dst |= RGB8_to_I(src[2], src[1], src[0]) >> 4;
+        src += readStride;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst = src[2] & 0xf0;
+        src += readStride;
+
+        *dst |= src[2] >> 4;
+        src += readStride;
+
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_I8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      *dst++ = RGB8_to_I(src[2], src[1], src[0]);
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = RGB8_to_I(src[2], src[1], src[0]);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = src[2];
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA4:
+  case EFBCopyFormat::RA4:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      *dst++ = 0xf0 | (RGB8_to_I(src[2], src[1], src[0]) >> 4);
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = 0xf0 | (RGB8_to_I(src[2], src[1], src[0]) >> 4);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = 0xf0 | (src[2] >> 4);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA8:
+  case EFBCopyFormat::RA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      *dst++ = 0xff;
-      *dst++ = RGB8_to_I(src[2], src[1], src[0]);
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = 0xff;
+        *dst++ = RGB8_to_I(src[2], src[1], src[0]);
 
-      src += readStride;
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        *dst++ = 0xff;
+        *dst++ = src[2];
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB565:
+  case EFBCopyFormat::RGB565:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -810,7 +873,7 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB5A3:
+  case EFBCopyFormat::RGB5A3:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -824,7 +887,7 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGBA8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -839,65 +902,14 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_R4:
-    SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
-    {
-      *dst = src[2] & 0xf0;
-      src += readStride;
-
-      *dst |= src[2] >> 4;
-      src += readStride;
-
-      dst++;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA4:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      *dst++ = 0xf0 | (src[2] >> 4);
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA8:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      *dst++ = 0xff;
-      *dst++ = src[2];
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_A8:
+  case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS { *dst++ = 0xff; }
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_R8:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      *dst++ = src[2];
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_G8:
+  case EFBCopyFormat::G8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -908,7 +920,7 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_B8:
+  case EFBCopyFormat::B8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -919,11 +931,12 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_RG8:
+  case EFBCopyFormat::RG8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
     {
+      // FIXME: is this backwards?
       *dst++ = src[1];
       *dst++ = src[2];
       src += readStride;
@@ -931,7 +944,7 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_GB8:
+  case EFBCopyFormat::GB8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -944,12 +957,12 @@ static void EncodeRGB8(u8* dst, const u8* src, u32 format)
     break;
 
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
 
-static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
+static void EncodeRGB8halfscale(u8* dst, const u8* src, EFBCopyFormat format, bool yuv)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -959,62 +972,122 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_I4:
+  case EFBCopyFormat::R4:
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGB_to_RGB8(src, &r, &g, &b);
-      *dst = RGB8_to_I(r, g, b) & 0xf0;
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_RGB8(src, &r, &g, &b);
+        *dst = RGB8_to_I(r, g, b) & 0xf0;
+        src += readStride;
 
-      BoxfilterRGB_to_RGB8(src, &r, &g, &b);
-      *dst |= RGB8_to_I(r, g, b) >> 4;
-      src += readStride;
-      dst++;
+        BoxfilterRGB_to_RGB8(src, &r, &g, &b);
+        *dst |= RGB8_to_I(r, g, b) >> 4;
+        src += readStride;
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_x8(src, &r, 2);
+        *dst = r & 0xf0;
+        src += readStride;
+
+        BoxfilterRGB_to_x8(src, &r, 2);
+        *dst |= r >> 4;
+        src += readStride;
+
+        dst++;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_I8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGB_to_RGB8(src, &r, &g, &b);
-      *dst++ = RGB8_to_I(r, g, b);
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_RGB8(src, &r, &g, &b);
+        *dst++ = RGB8_to_I(r, g, b);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_x8(src, &r, 2);
+        *dst++ = r;
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA4:
+  case EFBCopyFormat::RA4:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGB_to_RGB8(src, &r, &g, &b);
-      *dst++ = 0xf0 | (RGB8_to_I(r, g, b) >> 4);
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_RGB8(src, &r, &g, &b);
+        *dst++ = 0xf0 | (RGB8_to_I(r, g, b) >> 4);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_x8(src, &r, 2);
+        *dst++ = 0xf0 | (r >> 4);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_IA8:
+  case EFBCopyFormat::RA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
+    if (yuv)
     {
-      BoxfilterRGB_to_RGB8(src, &r, &g, &b);
-      *dst++ = 0xff;
-      *dst++ = RGB8_to_I(r, g, b);
-      src += readStride;
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_RGB8(src, &r, &g, &b);
+        *dst++ = 0xff;
+        *dst++ = RGB8_to_I(r, g, b);
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
+    }
+    else
+    {
+      ENCODE_LOOP_BLOCKS
+      {
+        BoxfilterRGB_to_x8(src, &r, 2);
+        *dst++ = 0xff;
+        *dst++ = r;
+        src += readStride;
+      }
+      ENCODE_LOOP_SPANS
     }
-    ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB565:
+  case EFBCopyFormat::RGB565:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1028,7 +1101,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGB5A3:
+  case EFBCopyFormat::RGB5A3:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1042,7 +1115,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_RGBA8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1058,70 +1131,14 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_R4:
-    SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    sBlkSize /= 2;
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGB_to_x8(src, &r, 2);
-      *dst = r & 0xf0;
-      src += readStride;
-
-      BoxfilterRGB_to_x8(src, &r, 2);
-      *dst |= r >> 4;
-      src += readStride;
-
-      dst++;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA4:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGB_to_x8(src, &r, 2);
-      *dst++ = 0xf0 | (r >> 4);
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_RA8:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGB_to_x8(src, &r, 2);
-      *dst++ = 0xff;
-      *dst++ = r;
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_A8:
+  case EFBCopyFormat::A8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS { *dst++ = 0xff; }
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_R8:
-    SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGB_to_x8(src, &r, 2);
-      *dst++ = r;
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
-
-  case GX_CTF_G8:
+  case EFBCopyFormat::G8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1133,7 +1150,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_B8:
+  case EFBCopyFormat::B8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1145,7 +1162,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_RG8:
+  case EFBCopyFormat::RG8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1158,7 +1175,7 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_GB8:
+  case EFBCopyFormat::GB8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1172,12 +1189,12 @@ static void EncodeRGB8halfscale(u8* dst, const u8* src, u32 format)
     break;
 
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
 
-static void EncodeZ24(u8* dst, const u8* src, u32 format)
+static void EncodeZ24(u8* dst, const u8* src, EFBCopyFormat format)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -1186,7 +1203,8 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_Z8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1197,19 +1215,9 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_Z16:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      *dst++ = src[1];
-      *dst++ = src[2];
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
+  // FIXME: handle RA8?
 
-  case GX_TF_Z24X8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1224,7 +1232,7 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_Z4:
+  case EFBCopyFormat::R4:
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
@@ -1241,7 +1249,7 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z8M:
+  case EFBCopyFormat::G8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1252,7 +1260,7 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z8L:
+  case EFBCopyFormat::B8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1263,7 +1271,20 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z16L:
+  case EFBCopyFormat::RG8:
+    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
+    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
+    ENCODE_LOOP_BLOCKS
+    {
+      // FIXME: should these be reversed?
+      *dst++ = src[1];
+      *dst++ = src[2];
+      src += readStride;
+    }
+    ENCODE_LOOP_SPANS
+    break;
+
+  case EFBCopyFormat::GB8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1276,12 +1297,12 @@ static void EncodeZ24(u8* dst, const u8* src, u32 format)
     break;
 
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
 
-static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
+static void EncodeZ24halfscale(u8* dst, const u8* src, EFBCopyFormat format)
 {
   u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize;
   s32 tSpan, sBlkSpan, tBlkSpan, writeStride;
@@ -1291,7 +1312,8 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
 
   switch (format)
   {
-  case GX_TF_Z8:
+  case EFBCopyFormat::R8_0x1:
+  case EFBCopyFormat::R8:
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1303,20 +1325,9 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_TF_Z16:
-    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
-    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
-    ENCODE_LOOP_BLOCKS
-    {
-      BoxfilterRGB_to_xx8(src, &g, &b, 1, 2);
-      *dst++ = b;
-      *dst++ = g;
-      src += readStride;
-    }
-    ENCODE_LOOP_SPANS
-    break;
+  // FIXME: handle RA8?
 
-  case GX_TF_Z24X8:
+  case EFBCopyFormat::RGBA8:
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1329,7 +1340,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS2
     break;
 
-  case GX_CTF_Z4:
+  case EFBCopyFormat::R4:  // Z4
     SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     sBlkSize /= 2;
@@ -1348,7 +1359,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z8M:
+  case EFBCopyFormat::G8:  // Z8M
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1360,7 +1371,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z8L:
+  case EFBCopyFormat::B8:  // Z8L
     SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1372,7 +1383,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
-  case GX_CTF_Z16L:
+  case EFBCopyFormat::RG8:  // RG8
     SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
     SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
     ENCODE_LOOP_BLOCKS
@@ -1385,8 +1396,22 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, u32 format)
     ENCODE_LOOP_SPANS
     break;
 
+  case EFBCopyFormat::GB8:
+    SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize);
+    SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride);
+    ENCODE_LOOP_BLOCKS
+    {
+      BoxfilterRGB_to_xx8(src, &g, &b, 1, 2);
+      // FIXME: is this backwards?
+      *dst++ = b;
+      *dst++ = g;
+      src += readStride;
+    }
+    ENCODE_LOOP_SPANS
+    break;
+
   default:
-    PanicAlert("Unknown texture copy format: 0x%x\n", format);
+    PanicAlert("Unknown texture copy format: 0x%x\n", static_cast<int>(format));
     break;
   }
 }
@@ -1396,21 +1421,7 @@ void Encode(u8* dest_ptr)
   auto pixelformat = bpmem.zcontrol.pixel_format;
   bool bFromZBuffer = pixelformat == PEControl::Z24;
   bool bIsIntensityFmt = bpmem.triggerEFBCopy.intensity_fmt > 0;
-  u32 copyfmt = ((bpmem.triggerEFBCopy.target_pixel_format / 2) +
-                 ((bpmem.triggerEFBCopy.target_pixel_format & 1) * 8));
-
-  // pack copy format information into a single variable
-  u32 format = copyfmt;
-  if (bFromZBuffer)
-  {
-    format |= _GX_TF_ZTF;
-    if (copyfmt == 11)
-      format = GX_TF_Z16;
-    else if (format < GX_TF_Z8 || format > GX_TF_Z24X8)
-      format |= _GX_TF_CTF;
-  }
-  else if (copyfmt > GX_TF_RGBA8 || (copyfmt < GX_TF_RGB565 && !bIsIntensityFmt))
-    format |= _GX_TF_CTF;
+  EFBCopyFormat copyfmt = bpmem.triggerEFBCopy.tp_realFormat();
 
   const u8* src =
       EfbInterface::GetPixelPointer(bpmem.copyTexSrcXY.x, bpmem.copyTexSrcXY.y, bFromZBuffer);
@@ -1418,24 +1429,24 @@ void Encode(u8* dest_ptr)
   if (bpmem.triggerEFBCopy.half_scale)
   {
     if (pixelformat == PEControl::RGBA6_Z24)
-      EncodeRGBA6halfscale(dest_ptr, src, format);
+      EncodeRGBA6halfscale(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::RGB8_Z24)
-      EncodeRGB8halfscale(dest_ptr, src, format);
+      EncodeRGB8halfscale(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::RGB565_Z16)  // not supported
-      EncodeRGB8halfscale(dest_ptr, src, format);
+      EncodeRGB8halfscale(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::Z24)
-      EncodeZ24halfscale(dest_ptr, src, format);
+      EncodeZ24halfscale(dest_ptr, src, copyfmt);
   }
   else
   {
     if (pixelformat == PEControl::RGBA6_Z24)
-      EncodeRGBA6(dest_ptr, src, format);
+      EncodeRGBA6(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::RGB8_Z24)
-      EncodeRGB8(dest_ptr, src, format);
+      EncodeRGB8(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::RGB565_Z16)  // not supported
-      EncodeRGB8(dest_ptr, src, format);
+      EncodeRGB8(dest_ptr, src, copyfmt, bIsIntensityFmt);
     else if (pixelformat == PEControl::Z24)
-      EncodeZ24(dest_ptr, src, format);
+      EncodeZ24(dest_ptr, src, copyfmt);
   }
 }
 }
diff --git a/Source/Core/VideoBackends/Software/TextureSampler.cpp b/Source/Core/VideoBackends/Software/TextureSampler.cpp
index 248e4a6f19..0decf134c9 100644
--- a/Source/Core/VideoBackends/Software/TextureSampler.cpp
+++ b/Source/Core/VideoBackends/Software/TextureSampler.cpp
@@ -111,13 +111,14 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample)
   TexMode0& tm0 = texUnit.texMode0[subTexmap];
   TexImage0& ti0 = texUnit.texImage0[subTexmap];
   TexTLUT& texTlut = texUnit.texTlut[subTexmap];
-  TlutFormat tlutfmt = (TlutFormat)texTlut.tlut_format;
+  TextureFormat texfmt = static_cast<TextureFormat>(ti0.format);
+  TLUTFormat tlutfmt = static_cast<TLUTFormat>(texTlut.tlut_format);
 
   u8 *imageSrc, *imageSrcOdd = nullptr;
   if (texUnit.texImage1[subTexmap].image_type)
   {
     imageSrc = &texMem[texUnit.texImage1[subTexmap].tmem_even * TMEM_LINE_SIZE];
-    if (ti0.format == GX_TF_RGBA8)
+    if (texfmt == TextureFormat::RGBA8)
       imageSrcOdd = &texMem[texUnit.texImage2[subTexmap].tmem_odd * TMEM_LINE_SIZE];
   }
   else
@@ -139,9 +140,9 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample)
     int mipWidth = imageWidth + 1;
     int mipHeight = imageHeight + 1;
 
-    int fmtWidth = TexDecoder_GetBlockWidthInTexels(ti0.format);
-    int fmtHeight = TexDecoder_GetBlockHeightInTexels(ti0.format);
-    int fmtDepth = TexDecoder_GetTexelSizeInNibbles(ti0.format);
+    int fmtWidth = TexDecoder_GetBlockWidthInTexels(texfmt);
+    int fmtHeight = TexDecoder_GetBlockHeightInTexels(texfmt);
+    int fmtDepth = TexDecoder_GetTexelSizeInNibbles(texfmt);
 
     imageWidth >>= mip;
     imageHeight >>= mip;
@@ -186,21 +187,21 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample)
     WrapCoord(&imageSPlus1, tm0.wrap_s, imageWidth);
     WrapCoord(&imageTPlus1, tm0.wrap_t, imageHeight);
 
-    if (!(ti0.format == GX_TF_RGBA8 && texUnit.texImage1[subTexmap].image_type))
+    if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].image_type))
     {
-      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageS, imageT, imageWidth, ti0.format, tlut,
+      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageS, imageT, imageWidth, texfmt, tlut,
                              tlutfmt);
       SetTexel(sampledTex, texel, (128 - fractS) * (128 - fractT));
 
-      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageSPlus1, imageT, imageWidth, ti0.format,
-                             tlut, tlutfmt);
+      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageSPlus1, imageT, imageWidth, texfmt, tlut,
+                             tlutfmt);
       AddTexel(sampledTex, texel, (fractS) * (128 - fractT));
 
-      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageS, imageTPlus1, imageWidth, ti0.format,
-                             tlut, tlutfmt);
+      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageS, imageTPlus1, imageWidth, texfmt, tlut,
+                             tlutfmt);
       AddTexel(sampledTex, texel, (128 - fractS) * (fractT));
 
-      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageSPlus1, imageTPlus1, imageWidth, ti0.format,
+      TexDecoder_DecodeTexel(sampledTex, imageSrc, imageSPlus1, imageTPlus1, imageWidth, texfmt,
                              tlut, tlutfmt);
       AddTexel(sampledTex, texel, (fractS) * (fractT));
     }
@@ -238,9 +239,8 @@ void SampleMip(s32 s, s32 t, s32 mip, bool linear, u8 texmap, u8* sample)
     WrapCoord(&imageS, tm0.wrap_s, imageWidth);
     WrapCoord(&imageT, tm0.wrap_t, imageHeight);
 
-    if (!(ti0.format == GX_TF_RGBA8 && texUnit.texImage1[subTexmap].image_type))
-      TexDecoder_DecodeTexel(sample, imageSrc, imageS, imageT, imageWidth, ti0.format, tlut,
-                             tlutfmt);
+    if (!(texfmt == TextureFormat::RGBA8 && texUnit.texImage1[subTexmap].image_type))
+      TexDecoder_DecodeTexel(sample, imageSrc, imageS, imageT, imageWidth, texfmt, tlut, tlutfmt);
     else
       TexDecoder_DecodeTexelRGBA8FromTmem(sample, imageSrc, imageSrcOdd, imageS, imageT,
                                           imageWidth);