Document image_processing_effects.c

1 files changed, 542 insertions, 873 deletions

diff --git a/src/image_processing_effects.c b/src/image_processing_effects.c
index f0f44d6e5..fe5fc5dd9 100644
--- a/src/image_processing_effects.c
+++ b/src/image_processing_effects.c
@@ -2,136 +2,145 @@
 #include "image_processing_effects.h"
 #include "contest_painting.h"
 
-extern const u8 gUnknown_083E7A50[][3];
-
-u16 (*gUnknown_03005DEC)[][32];
-u8 gUnknown_03005DE8;
-u8 gUnknown_03005DF0;
-u8 gUnknown_03005DFC;
-u8 gUnknown_03005DF8;
-u8 gUnknown_03005DF4;
-u8 gUnknown_03005E00;
-u8 gUnknown_03005E04;
-u16 * gUnknown_03005E08;
-u16 gUnknown_03005E0C;
+#define GET_R(color) ((color) & 0x1F)
+#define GET_G(color) (((color) >> 5) & 0x1F)
+#define GET_B(color) (((color) >> 10) & 0x1F)
+
+#define RGB_ALPHA       (1 << 15)
+#define IS_ALPHA(color) ((color) & RGB_ALPHA)
+
+#define RGB2(r, g, b) (((b) << 10) | ((g) << 5) | (r))
+
+u16 *gCanvasPixels;
+u8 gCanvasColumnStart;
+u8 gCanvasRowEnd;
+u8 gCanvasRowStart;
+u8 gCanvasColumnEnd;
+u8 gCanvasHeight;
+u8 gCanvasMonPersonality;
+u8 gCanvasWidth;
+u16 * gCanvasPalette;
+u16 gCanvasPaletteStart;
 
 // this file's functions
-void sub_80FCAA4(void);
-void sub_80FCB5C(void);
-void sub_80FCD54(void);
-void sub_80FCEA4(void);
-void sub_80FCCBC(void);
-void sub_80FD06C(void);
-void sub_80FD114(void);
-void sub_80FCF3C(void);
-void sub_80FCAC4(void);
-void sub_80FCC18(u8);
-void sub_80FC92C(u8);
-void sub_80FC9E4(u8);
-void sub_80FD1C8(u16);
+void ApplyImageEffect_Pointillism(void);
+void ApplyImageEffect_Blur(void);
+void ApplyImageEffect_BlackOutline(void);
+void ApplyImageEffect_Invert(void);
+void ApplyImageEffect_BlackAndWhite(void);
+void ApplyImageEffect_BlurRight(void);
+void ApplyImageEffect_BlurDown(void);
+void ApplyImageEffect_Shimmer(void);
+void ApplyImageEffect_Grayscale(void);
+void ApplyImageEffect_PersonalityColor(u8 personality);
+void ApplyImageEffect_RedChannelGrayscale(u8);
+void ApplyImageEffect_RedChannelGrayscaleHighlight(u8);
+void AddPointillismPoints(u16);
 u16 ConvertColorToGrayscale(u16*);
-u16 sub_80FD68C(u16*, u16*, u16*);
+u16 QuantizePixel_Blur(u16 *prevPixel, u16 *curPixel, u16 *nextPixel);
 u16 ConvertCoolColor(u16*, u8);
-u16 ConvertToBlackOrWhite(u16*);
-u16 sub_80FD50C(u16*, u16*);
-u16 InvertColor(u16*);
-u16 sub_80FD7AC(u16*, u16*, u16*);
-u16 sub_80FD568(u16*, u16*);
+u16 QuantizePixel_BlackAndWhite(u16*);
+u16 QuantizePixel_BlackOutline(u16 *colorA, u16 *colorB);
+u16 QuantizePixel_Invert(u16*);
+u16 QuantizePixel_BlurHard(u16 *prevPixel, u16 *curPixel, u16 *nextPixel);
+u16 QuantizePixel_MotionBlur(u16*, u16*);
 u16 GetCoolColorFromPersonality(u8);
-void sub_80FDC18(bool8);
-void sub_80FDAE4(void);
-void sub_80FDF88(void);
-void sub_80FDBE4(void);
-void sub_80FDED8(void);
-void sub_80FDBA8(void);
-void sub_80FDE28(void);
-void sub_80FDB8C(void);
-void sub_80FDD70(void);
-u16 sub_80FE038(u16 *);
-u16 sub_80FE17C(u16 *);
-u16 sub_80FE1B0(u16 *);
-u16 sub_80FE0AC(u16 *);
-
-void sub_80FC7A0(struct ImageProcessingContext* info)
+void QuantizePalette_Standard(bool8);
+void SetPresetPalette_PrimaryColors(void);
+void QuantizePalette_PrimaryColors(void);
+void SetPresetPalette_Grayscale(void);
+void QuantizePalette_Grayscale(void);
+void SetPresetPalette_GrayscaleSmall(void);
+void QuantizePalette_GrayscaleSmall(void);
+void SetPresetPalette_BlackAndWhite(void);
+void QuantizePalette_BlackAndWhite(void);
+u16 QuantizePixel_Standard(u16 *);
+u16 QuantizePixel_GrayscaleSmall(u16 *);
+u16 QuantizePixel_Grayscale(u16 *);
+u16 QuantizePixel_PrimaryColors(u16 *);
+
+#define MAX_DIMENSION 64
+
+#include "data/pointillism_points.h"
+
+void ApplyImageProcessingEffects(struct ImageProcessingContext* info)
 {
-    gUnknown_03005DEC = info->var_4;
-    gUnknown_03005E00 = info->var_1F;
-    gUnknown_03005DE8 = info->var_19;
-    gUnknown_03005DFC = info->var_1A;
-    gUnknown_03005DF8 = info->var_1B;
-    gUnknown_03005DF0 = info->var_1C;
-    gUnknown_03005E04 = info->var_1D;
-    gUnknown_03005DF4 = info->var_1E;
-    switch (info->var_0)
+    gCanvasPixels = info->canvasPixels;
+    gCanvasMonPersonality = info->personality;
+    gCanvasColumnStart = info->columnStart;
+    gCanvasRowStart = info->rowStart;
+    gCanvasColumnEnd = info->columnEnd;
+    gCanvasRowEnd = info->rowEnd;
+    gCanvasWidth = info->canvasWidth;
+    gCanvasHeight = info->canvasHeight;
+    switch (info->effect)
     {
-    case 2:
-        sub_80FCAA4();
+    case IMAGE_EFFECT_POINTILLISM:
+        ApplyImageEffect_Pointillism();
         break;
-    case 8:
-        sub_80FCB5C();
+    case IMAGE_EFFECT_BLUR:
+        ApplyImageEffect_Blur();
         break;
-    case 9:
-        sub_80FCD54();
-        sub_80FCC18(gUnknown_03005E00);
+    case IMAGE_EFFECT_OUTLINE_COLORED:
+        ApplyImageEffect_BlackOutline();
+        ApplyImageEffect_PersonalityColor(gCanvasMonPersonality);
         break;
-    case 10:
-        sub_80FCD54();
-        sub_80FCEA4();
-        sub_80FCCBC();
-    case 31:
-        sub_80FCEA4();
+    case IMAGE_EFFECT_INVERT_BLACK_WHITE:
+        ApplyImageEffect_BlackOutline();
+        ApplyImageEffect_Invert();
+        ApplyImageEffect_BlackAndWhite();
+    case IMAGE_EFFECT_INVERT:
+        ApplyImageEffect_Invert();
         break;
-    case 11:
-        sub_80FCD54();
-        sub_80FD06C();
-        sub_80FD06C();
-        sub_80FD114();
-        sub_80FCCBC();
+    case IMAGE_EFFECT_THICK_BLACK_WHITE:
+        ApplyImageEffect_BlackOutline();
+        ApplyImageEffect_BlurRight();
+        ApplyImageEffect_BlurRight();
+        ApplyImageEffect_BlurDown();
+        ApplyImageEffect_BlackAndWhite();
         break;
-    case 13:
-        sub_80FCF3C();
+    case IMAGE_EFFECT_SHIMMER:
+        ApplyImageEffect_Shimmer();
         break;
-    case 30:
-        sub_80FCD54();
+    case IMAGE_EFFECT_OUTLINE:
+        ApplyImageEffect_BlackOutline();
         break;
-    case 32:
-        sub_80FD06C();
+    case IMAGE_EFFECT_BLUR_RIGHT:
+        ApplyImageEffect_BlurRight();
         break;
-    case 33:
-        sub_80FD114();
+    case IMAGE_EFFECT_BLUR_DOWN:
+        ApplyImageEffect_BlurDown();
         break;
-    case 6:
-        sub_80FCAC4();
-        sub_80FC92C(3);
+    case IMAGE_EFFECT_GRAYSCALE_LIGHT:
+        ApplyImageEffect_Grayscale();
+        ApplyImageEffect_RedChannelGrayscale(3);
         break;
-    case 36:
-        sub_80FCD54();
-        sub_80FD06C();
-        sub_80FD114();
-        sub_80FCCBC();
-        sub_80FCB5C();
-        sub_80FCB5C();
-        sub_80FC92C(2);
-        sub_80FC9E4(4);
+    case IMAGE_EFFECT_CHARCOAL:
+        ApplyImageEffect_BlackOutline();
+        ApplyImageEffect_BlurRight();
+        ApplyImageEffect_BlurDown();
+        ApplyImageEffect_BlackAndWhite();
+        ApplyImageEffect_Blur();
+        ApplyImageEffect_Blur();
+        ApplyImageEffect_RedChannelGrayscale(2);
+        ApplyImageEffect_RedChannelGrayscaleHighlight(4);
         break;
     }
 }
 
-#define RGB2(r, g, b) (((b) << 10) | ((g) << 5) | (r))
-
-void sub_80FC92C(u8 a0) // it changes palette someway somehow... .__.
+void ApplyImageEffect_RedChannelGrayscale(u8 delta)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (!(0x8000 & *pal))
+            if (!IS_ALPHA(*pal))
             {
                 u8 val = (31 & *pal);
-                val += a0;
+                val += delta;
                 if (val > 31)
                     val = 31;
 
@@ -141,20 +150,20 @@ void sub_80FC92C(u8 a0) // it changes palette someway somehow... .__.
     }
 }
 
-void sub_80FC9E4(u8 a0)
+void ApplyImageEffect_RedChannelGrayscaleHighlight(u8 highlight)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (!(0x8000 & *pal))
+            if (!IS_ALPHA(*pal))
             {
                 u8 val = (31 & *pal);
-                if (val > 31 - a0)
-                    val = 31 - (a0 >> 1);
+                if (val > 31 - highlight)
+                    val = 31 - (highlight >> 1);
 
                 *pal = RGB2(val, val, val);
             }
@@ -162,23 +171,23 @@ void sub_80FC9E4(u8 a0)
     }
 }
 
-void sub_80FCAA4(void)
+void ApplyImageEffect_Pointillism(void)
 {
     u32 i;
     for (i = 0; i < 3200; i++)
-        sub_80FD1C8(i);
+        AddPointillismPoints(i);
 }
 
-void sub_80FCAC4(void)
+void ApplyImageEffect_Grayscale(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* color = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, color++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* color = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, color++)
         {
-            if (!(0x8000 & *color))
+            if (!IS_ALPHA(*color))
             {
                 *color = ConvertColorToGrayscale(color);
             }
@@ -186,479 +195,316 @@ void sub_80FCAC4(void)
     }
 }
 
-void sub_80FCB5C(void)
+void ApplyImageEffect_Blur(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF8; i++)
+    for (i = 0; i < gCanvasColumnEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][gUnknown_03005DFC * gUnknown_03005E04];
-        u16* palette = &var0[gUnknown_03005DE8 + i];
+        u16* var0 = &gCanvasPixels[gCanvasRowStart * gCanvasWidth];
+        u16* palette = &var0[gCanvasColumnStart + i];
         u16 color = *palette;
         j = 1;
-        palette += gUnknown_03005E04;
-        while (j < gUnknown_03005DF0 - 1)
+        palette += gCanvasWidth;
+        while (j < gCanvasRowEnd - 1)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*palette))
             {
-                *palette = sub_80FD68C(&color, palette, palette + gUnknown_03005E04);
+                *palette = QuantizePixel_Blur(&color, palette, palette + gCanvasWidth);
                 color = *palette;
             }
 
             j++;
-            palette += gUnknown_03005E04;
+            palette += gCanvasWidth;
         }
     }
 }
 
-void sub_80FCC18(u8 arg0)
+void ApplyImageEffect_PersonalityColor(u8 personality)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* color = &var0[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, color++)
+        u16* pixelRow = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pixel = &pixelRow[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pixel++)
         {
-            if (!(0x8000 & *color))
+            if (!IS_ALPHA(*pixel))
             {
-                *color = ConvertCoolColor(color, arg0);
+                *pixel = ConvertCoolColor(pixel, personality);
             }
         }
     }
 }
 
-void sub_80FCCBC(void)
+void ApplyImageEffect_BlackAndWhite(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* color = &var0[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, color++)
+        u16* pixelRow = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pixel = &pixelRow[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pixel++)
         {
-            if (!(0x8000 & *color))
+            if (!IS_ALPHA(*pixel))
             {
-                *color = ConvertToBlackOrWhite(color);
+                *pixel = QuantizePixel_BlackAndWhite(pixel);
             }
         }
     }
 }
  
-void sub_80FCD54(void)
+void ApplyImageEffect_BlackOutline(void)
 {
     u8 i, j;
-    u16 *palette;
+    u16 *pixel;
 
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        palette = &var0[gUnknown_03005DE8];
-        *palette = sub_80FD50C(palette, palette + 1);
-        for (j = 1, palette = palette + 1; j < gUnknown_03005DF8 - 1; j++, palette++)
+        u16* pixelRow = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        pixel = &pixelRow[gCanvasColumnStart];
+        *pixel = QuantizePixel_BlackOutline(pixel, pixel + 1);
+        for (j = 1, pixel = pixel + 1; j < gCanvasColumnEnd - 1; j++, pixel++)
         {
-            *palette = sub_80FD50C(palette, palette + 1);
-            *palette = sub_80FD50C(palette, palette - 1);
+            *pixel = QuantizePixel_BlackOutline(pixel, pixel + 1);
+            *pixel = QuantizePixel_BlackOutline(pixel, pixel - 1);
         }
 
-        *palette = sub_80FD50C(palette, palette - 1);
+        *pixel = QuantizePixel_BlackOutline(pixel, pixel - 1);
     }
 
-    for (j = 0; j < gUnknown_03005DF8; j++)
+    for (j = 0; j < gCanvasColumnEnd; j++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][gUnknown_03005DFC * gUnknown_03005E04];
-        palette = &var0[gUnknown_03005DE8 + j];
-        *palette = sub_80FD50C(palette, palette + gUnknown_03005E04);
-        for (i = 1, palette = palette + gUnknown_03005E04; i < gUnknown_03005DF0 - 1; i++, palette += gUnknown_03005E04)
+        u16* var0 = &gCanvasPixels[gCanvasRowStart * gCanvasWidth];
+        pixel = &var0[gCanvasColumnStart + j];
+        *pixel = QuantizePixel_BlackOutline(pixel, pixel + gCanvasWidth);
+        for (i = 1, pixel = pixel + gCanvasWidth; i < gCanvasRowEnd - 1; i++, pixel += gCanvasWidth)
         {
-            *palette = sub_80FD50C(palette, palette + gUnknown_03005E04);
-            *palette = sub_80FD50C(palette, palette - gUnknown_03005E04);
+            *pixel = QuantizePixel_BlackOutline(pixel, pixel + gCanvasWidth);
+            *pixel = QuantizePixel_BlackOutline(pixel, pixel - gCanvasWidth);
         }
 
-        *palette = sub_80FD50C(palette, palette - gUnknown_03005E04);
+        *pixel = QuantizePixel_BlackOutline(pixel, pixel - gCanvasWidth);
     }
 }
 
-void sub_80FCEA4(void)
+void ApplyImageEffect_Invert(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* color = &var0[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, color++)
+        u16* pixelRow = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pixel = &pixelRow[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pixel++)
         {
-            if (!(0x8000 & *color))
+            if (!IS_ALPHA(*pixel))
             {
-                *color = InvertColor(color);
+                *pixel = QuantizePixel_Invert(pixel);
             }
         }
     }
 }
 
-void sub_80FCF3C(void)
+void ApplyImageEffect_Shimmer(void)
 {
     u8 i, j;
-    u16 *palette;
+    u16 *pixel;
     u16 color;
 
-    palette = (*gUnknown_03005DEC)[0];
+    pixel = gCanvasPixels;
     for (i = 0; i < 64; i++)
     {
-        for (j = 0; j < 64; j++, palette++)
+        for (j = 0; j < 64; j++, pixel++)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = InvertColor(palette);
+                *pixel = QuantizePixel_Invert(pixel);
             }
         }
     }
 
     for (j = 0; j < 64; j++)
     {
-        palette = &(*gUnknown_03005DEC)[0][j];
-        color = *palette;
-        *palette = 0x8000;
-        for (i = 1, palette += 64; i < 63; i++, palette += 64)
+        pixel = &gCanvasPixels[j];
+        color = *pixel;
+        *pixel = RGB_ALPHA;
+        for (i = 1, pixel += 64; i < 63; i++, pixel += 64)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = sub_80FD7AC(&color, palette, palette + 64);
-                color = *palette;
+                *pixel = QuantizePixel_BlurHard(&color, pixel, pixel + 64);
+                color = *pixel;
             }
         }
 
-        *palette = 0x8000;
-        palette = &(*gUnknown_03005DEC)[0][j];
-        color = *palette;
-        *palette = 0x8000;
-        for (i = 1, palette += 64; i < 63; i++, palette += 64)
+        *pixel = RGB_ALPHA;
+        pixel = &gCanvasPixels[j];
+        color = *pixel;
+        *pixel = RGB_ALPHA;
+        for (i = 1, pixel += 64; i < 63; i++, pixel += 64)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = sub_80FD7AC(&color, palette, palette + 64);
-                color = *palette;
+                *pixel = QuantizePixel_BlurHard(&color, pixel, pixel + 64);
+                color = *pixel;
             }
         }
 
-        *palette = 0x8000;
+        *pixel = RGB_ALPHA;
     }
 
-    palette = (*gUnknown_03005DEC)[0];
+    pixel = gCanvasPixels;
     for (i = 0; i < 64; i++)
     {
-        for (j = 0; j < 64; j++, palette++)
+        for (j = 0; j < 64; j++, pixel++)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = InvertColor(palette);
+                *pixel = QuantizePixel_Invert(pixel);
             }
         }
     }
 }
 
-void sub_80FD06C(void)
+void ApplyImageEffect_BlurRight(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* palette = &var0[gUnknown_03005DE8];
-        u16 color = *palette;
-        for (j = 1, palette++; j < gUnknown_03005DF8 - 1; j++, palette++)
+        u16* pixelRow = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pixel = &pixelRow[gCanvasColumnStart];
+        u16 color = *pixel;
+        for (j = 1, pixel++; j < gCanvasColumnEnd - 1; j++, pixel++)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = sub_80FD568(&color, palette);
-                color = *palette;
+                *pixel = QuantizePixel_MotionBlur(&color, pixel);
+                color = *pixel;
             }
         }
     }
 }
 
-void sub_80FD114(void)
+void ApplyImageEffect_BlurDown(void)
 {
     u8 i, j;
-    for (i = 0; i < gUnknown_03005DF8; i++)
+    for (i = 0; i < gCanvasColumnEnd; i++)
     {
-        u16* var0 = &(*gUnknown_03005DEC)[0][gUnknown_03005DFC * gUnknown_03005E04];
-        u16* palette = &var0[gUnknown_03005DE8 + i];
-        u16 color = *palette;
-        for (j = 1, palette += gUnknown_03005E04; j < gUnknown_03005DF0 - 1; j++, palette += gUnknown_03005E04)
+        u16* pixelRow = &gCanvasPixels[gCanvasRowStart * gCanvasWidth];
+        u16* pixel = &pixelRow[gCanvasColumnStart + i];
+        u16 prevPixel = *pixel;
+        for (j = 1, pixel += gCanvasWidth; j < gCanvasRowEnd - 1; j++, pixel += gCanvasWidth)
         {
-            if (!(0x8000 & *palette))
+            if (!IS_ALPHA(*pixel))
             {
-                *palette = sub_80FD568(&color, palette);
-                color = *palette;
+                *pixel = QuantizePixel_MotionBlur(&prevPixel, pixel);
+                prevPixel = *pixel;
             }
         }
     }
 }
 
-NAKED
-void sub_80FD1C8(u16 arg0)
+struct PointillismPoint
+{
+    u8 column;
+    u8 row;
+    u16 delta;
+};
+
+void AddPointillismPoints(u16 point)
 {
-    asm(".syntax unified\n\
-    push {r4-r7,lr}\n\
-    mov r7, r10\n\
-    mov r6, r9\n\
-    mov r5, r8\n\
-    push {r5-r7}\n\
-    sub sp, 0x20\n\
-    lsls r0, 16\n\
-    lsrs r0, 16\n\
-    mov r10, r0\n\
-    mov r2, sp\n\
-    ldr r3, _080FD234 @ =gUnknown_083E7A50\n\
-    lsls r1, r0, 1\n\
-    add r1, r10\n\
-    adds r0, r1, r3\n\
-    ldrb r0, [r0]\n\
-    strb r0, [r2]\n\
-    adds r0, r3, 0x1\n\
-    adds r0, r1, r0\n\
-    ldrb r0, [r0]\n\
-    strb r0, [r2, 0x1]\n\
-    mov r5, sp\n\
-    adds r0, r3, 0x2\n\
-    adds r1, r0\n\
-    ldrb r4, [r1]\n\
-    lsls r2, r4, 24\n\
-    lsrs r1, r2, 27\n\
-    movs r0, 0x7\n\
-    ands r1, r0\n\
-    strh r1, [r5, 0x2]\n\
-    lsrs r2, 25\n\
-    mov r9, r2\n\
-    movs r0, 0x3\n\
-    ands r2, r0\n\
-    mov r9, r2\n\
-    movs r5, 0x1\n\
-    ands r5, r4\n\
-    movs r4, 0x1\n\
-    mov r8, r4\n\
-    cmp r8, r1\n\
-    bcs _080FD27A\n\
-    mov r3, sp\n\
-_080FD21A:\n\
-    cmp r5, 0\n\
-    bne _080FD238\n\
-    mov r0, r8\n\
-    lsls r2, r0, 2\n\
-    mov r4, sp\n\
-    adds r1, r4, r2\n\
-    ldrb r0, [r3]\n\
-    mov r4, r8\n\
-    subs r0, r4\n\
-    strb r0, [r1]\n\
-    ldrb r0, [r3, 0x1]\n\
-    add r0, r8\n\
-    b _080FD24A\n\
-    .align 2, 0\n\
-_080FD234: .4byte gUnknown_083E7A50\n\
-_080FD238:\n\
-    mov r0, r8\n\
-    lsls r2, r0, 2\n\
-    mov r4, sp\n\
-    adds r1, r4, r2\n\
-    ldrb r0, [r3]\n\
-    adds r0, 0x1\n\
-    strb r0, [r1]\n\
-    ldrb r0, [r3, 0x1]\n\
-    subs r0, 0x1\n\
-_080FD24A:\n\
-    strb r0, [r1, 0x1]\n\
-    add r2, sp\n\
-    ldrb r0, [r2]\n\
-    cmp r0, 0x3F\n\
-    bhi _080FD25A\n\
-    ldrb r0, [r2, 0x1]\n\
-    cmp r0, 0x3F\n\
-    bls _080FD262\n\
-_080FD25A:\n\
-    mov r0, r8\n\
-    subs r0, 0x1\n\
-    strh r0, [r3, 0x2]\n\
-    b _080FD27A\n\
-_080FD262:\n\
-    ldrh r0, [r3, 0x2]\n\
-    mov r1, r8\n\
-    subs r0, r1\n\
-    strh r0, [r2, 0x2]\n\
-    mov r0, r8\n\
-    adds r0, 0x1\n\
-    lsls r0, 24\n\
-    lsrs r0, 24\n\
-    mov r8, r0\n\
-    ldrh r0, [r3, 0x2]\n\
-    cmp r8, r0\n\
-    bcc _080FD21A\n\
-_080FD27A:\n\
-    movs r2, 0\n\
-    mov r8, r2\n\
-    mov r0, sp\n\
-    ldrh r0, [r0, 0x2]\n\
-    cmp r8, r0\n\
-    bcc _080FD288\n\
-    b _080FD38A\n\
-_080FD288:\n\
-    movs r3, 0x1F\n\
-_080FD28A:\n\
-    ldr r1, _080FD2E8 @ =gUnknown_03005DEC\n\
-    mov r4, r8\n\
-    lsls r0, r4, 2\n\
-    mov r2, sp\n\
-    adds r6, r2, r0\n\
-    ldrb r0, [r6, 0x1]\n\
-    lsls r0, 7\n\
-    ldr r1, [r1]\n\
-    adds r1, r0\n\
-    ldrb r0, [r6]\n\
-    lsls r0, 1\n\
-    adds r2, r1, r0\n\
-    ldrh r1, [r2]\n\
-    movs r4, 0x80\n\
-    lsls r4, 8\n\
-    adds r0, r4, 0\n\
-    ands r0, r1\n\
-    cmp r0, 0\n\
-    bne _080FD376\n\
-    movs r7, 0x1F\n\
-    ands r7, r1\n\
-    lsls r0, r1, 16\n\
-    lsrs r5, r0, 21\n\
-    ands r5, r3\n\
-    lsrs r4, r0, 26\n\
-    ands r4, r3\n\
-    mov r0, r9\n\
-    cmp r0, 0\n\
-    blt _080FD36C\n\
-    cmp r0, 0x1\n\
-    ble _080FD2EC\n\
-    cmp r0, 0x3\n\
-    bgt _080FD36C\n\
-    ldrh r0, [r6, 0x2]\n\
-    adds r1, r7, r0\n\
-    lsls r1, 16\n\
-    lsrs r7, r1, 16\n\
-    adds r1, r5, r0\n\
-    lsls r1, 16\n\
-    lsrs r5, r1, 16\n\
-    adds r0, r4, r0\n\
-    lsls r0, 16\n\
-    lsrs r4, r0, 16\n\
-    cmp r7, 0x1F\n\
-    bls _080FD360\n\
-    movs r7, 0x1F\n\
-    b _080FD360\n\
-    .align 2, 0\n\
-_080FD2E8: .4byte gUnknown_03005DEC\n\
-_080FD2EC:\n\
-    mov r1, r10\n\
-    lsls r0, r1, 1\n\
-    add r0, r10\n\
-    ldr r1, _080FD320 @ =gUnknown_083E7A50\n\
-    adds r1, 0x2\n\
-    adds r0, r1\n\
-    ldrb r0, [r0]\n\
-    lsrs r0, 3\n\
-    movs r1, 0x7\n\
-    ands r0, r1\n\
-    movs r1, 0x3\n\
-    str r2, [sp, 0x18]\n\
-    str r3, [sp, 0x1C]\n\
-    bl __umodsi3\n\
-    lsls r0, 24\n\
-    lsrs r0, 24\n\
-    ldr r2, [sp, 0x18]\n\
-    ldr r3, [sp, 0x1C]\n\
-    cmp r0, 0x1\n\
-    beq _080FD33C\n\
-    cmp r0, 0x1\n\
-    bgt _080FD324\n\
-    cmp r0, 0\n\
-    beq _080FD32A\n\
-    b _080FD36C\n\
-    .align 2, 0\n\
-_080FD320: .4byte gUnknown_083E7A50\n\
-_080FD324:\n\
-    cmp r0, 0x2\n\
-    beq _080FD34E\n\
-    b _080FD36C\n\
-_080FD32A:\n\
-    ldrh r0, [r6, 0x2]\n\
-    cmp r7, r0\n\
-    bcc _080FD338\n\
-    subs r0, r7, r0\n\
-    lsls r0, 16\n\
-    lsrs r7, r0, 16\n\
-    b _080FD36C\n\
-_080FD338:\n\
-    movs r7, 0\n\
-    b _080FD36C\n\
-_080FD33C:\n\
-    ldrh r0, [r6, 0x2]\n\
-    cmp r5, r0\n\
-    bcc _080FD34A\n\
-    subs r0, r5, r0\n\
-    lsls r0, 16\n\
-    lsrs r5, r0, 16\n\
-    b _080FD36C\n\
-_080FD34A:\n\
-    movs r5, 0\n\
-    b _080FD36C\n\
-_080FD34E:\n\
-    ldrh r0, [r6, 0x2]\n\
-    cmp r4, r0\n\
-    bcc _080FD35C\n\
-    subs r0, r4, r0\n\
-    lsls r0, 16\n\
-    lsrs r4, r0, 16\n\
-    b _080FD36C\n\
-_080FD35C:\n\
-    movs r4, 0\n\
-    b _080FD36C\n\
-_080FD360:\n\
-    cmp r5, 0x1F\n\
-    bls _080FD366\n\
-    movs r5, 0x1F\n\
-_080FD366:\n\
-    cmp r4, 0x1F\n\
-    bls _080FD36C\n\
-    movs r4, 0x1F\n\
-_080FD36C:\n\
-    lsls r0, r4, 10\n\
-    lsls r1, r5, 5\n\
-    orrs r0, r1\n\
-    orrs r7, r0\n\
-    strh r7, [r2]\n\
-_080FD376:\n\
-    mov r0, r8\n\
-    adds r0, 0x1\n\
-    lsls r0, 24\n\
-    lsrs r0, 24\n\
-    mov r8, r0\n\
-    mov r0, sp\n\
-    ldrh r0, [r0, 0x2]\n\
-    cmp r8, r0\n\
-    bcs _080FD38A\n\
-    b _080FD28A\n\
-_080FD38A:\n\
-    add sp, 0x20\n\
-    pop {r3-r5}\n\
-    mov r8, r3\n\
-    mov r9, r4\n\
-    mov r10, r5\n\
-    pop {r4-r7}\n\
-    pop {r0}\n\
-    bx r0\n\
-    .syntax divided\n");
+    u8 i;
+    bool8 offsetDownLeft;
+    u8 colorType;
+    struct PointillismPoint points[6];
+
+    points[0].column = sPointillismPoints[point][0];
+    points[0].row = sPointillismPoints[point][1];
+    points[0].delta = GET_POINT_DELTA(sPointillismPoints[point][2]);
+
+    colorType = GET_POINT_COLOR_TYPE(sPointillismPoints[point][2]);
+    offsetDownLeft = GET_POINT_OFFSET_DL(sPointillismPoints[point][2]);
+    for (i = 1; i < points[0].delta; i++)
+    {
+        if (!offsetDownLeft)
+        {
+            points[i].column = points[0].column - i;
+            points[i].row = points[0].row + i;
+        }
+        else
+        {
+            points[i].column = points[0].column + 1;
+            points[i].row = points[0].row - 1;
+        }
+
+        if (points[i].column >= MAX_DIMENSION || points[i].row >= MAX_DIMENSION)
+        {
+            points[0].delta = i - 1;
+            break;
+        }
+
+        points[i].delta = points[0].delta - i;
+    }
+
+    for (i = 0; i < points[0].delta; i++)
+    {
+        u16 *pixel = &gCanvasPixels[points[i].row * MAX_DIMENSION] + points[i].column;
+
+        if (!IS_ALPHA(*pixel))
+        {
+            u16 red =   GET_R(*pixel);
+            u16 green = GET_G(*pixel);
+            u16 blue =  GET_B(*pixel);
+
+            switch (colorType)
+            {
+            case 0:
+            case 1:
+                switch (GET_POINT_DELTA(sPointillismPoints[point][2]) % 3)
+                {
+                case 0:
+                    if (red >= points[i].delta)
+                        red -= points[i].delta;
+                    else
+                        red = 0;
+                    break;
+                case 1:
+                    if (green >= points[i].delta)
+                        green -= points[i].delta;
+                    else
+                        green = 0;
+                    break;
+                case 2:
+                    if (blue >= points[i].delta)
+                        blue -= points[i].delta;
+                    else
+                        blue = 0;
+                    break;
+                }
+                break;
+            case 2:
+            case 3:
+                red += points[i].delta;
+                green += points[i].delta;
+                blue += points[i].delta;
+                if (red > 31)
+                    red = 31;
+                if (green > 31)
+                    green = 31;
+                if (blue > 31)
+                    blue = 31;
+                break;
+            }
+
+            *pixel = RGB2(red, green, blue);
+        }
+    }
 }
 
 u16 ConvertColorToGrayscale(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     u16 average = (red + green + blue) / 3;
     return RGB2(average, average, average);
 }
@@ -667,13 +513,13 @@ u16 ConvertColorToGrayscale(u16 *color)
 // Everything else is white.
 u16 ConvertCoolColor(u16 *color, u8 personality)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     if (red < 17 && green < 17 && blue < 17)
         return GetCoolColorFromPersonality(personality);
     else
-        return RGB2(31, 31, 31);
+        return RGB_WHITE;
 }
 
 // Based on the given value, which comes from the first 8 bits of
@@ -729,37 +575,37 @@ u16 GetCoolColorFromPersonality(u8 personality)
     return RGB2(red, green, blue);
 }
 
-u16 ConvertToBlackOrWhite(u16 *color)
+u16 QuantizePixel_BlackAndWhite(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     if (red < 17 && green < 17 && blue < 17)
-        return RGB2(0, 0, 0);
+        return RGB_BLACK;
     else
-        return RGB2(31, 31, 31);
+        return RGB_WHITE;
 }
 
-u16 sub_80FD50C(u16 *colorA, u16 *colorB)
+u16 QuantizePixel_BlackOutline(u16 *colorA, u16 *colorB)
 {
     if (*colorA)
     {
-        if (*colorA & 0x8000)
-            return 0x8000;
-        if (*colorB & 0x8000)
-            return RGB2(0, 0, 0);
+        if (IS_ALPHA(*colorA))
+            return RGB_ALPHA;
+        if (IS_ALPHA(*colorB))
+            return RGB_BLACK;
 
         return *colorA;
     }
 
-    return RGB2(0, 0, 0);
+    return RGB_BLACK;
 }
 
-u16 InvertColor(u16 *color)
+u16 QuantizePixel_Invert(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     red = 31 - red;
     green = 31 - green;
     blue = 31 - blue;
@@ -767,63 +613,63 @@ u16 InvertColor(u16 *color)
     return RGB2(red, green, blue);
 }
 
-u16 sub_80FD568(u16 *a0, u16 *a1)
+u16 QuantizePixel_MotionBlur(u16 *prevPixel, u16 *curPixel)
 {
-    u16 sp0[2][3];
-    u16 spC[3];
-    u8 r4;
-    u16 r2;
+    u16 pixelChannels[2][3];
+    u16 diffs[3];
+    u8 i;
+    u16 largestDiff;
     u16 r, g, b;
 
-    if (*a0 == *a1)
-        return *a1;
+    if (*prevPixel == *curPixel)
+        return *curPixel;
 
-    sp0[0][0] = (*a0 >> 0) & 0x1F;
-    sp0[0][1] = (*a0 >> 5) & 0x1F;
-    sp0[0][2] = (*a0 >> 10) & 0x1F;
-    sp0[1][0] = (*a1 >> 0) & 0x1F;
-    sp0[1][1] = (*a1 >> 5) & 0x1F;
-    sp0[1][2] = (*a1 >> 10) & 0x1F;
+    pixelChannels[0][0] = GET_R(*prevPixel);
+    pixelChannels[0][1] = GET_G(*prevPixel);
+    pixelChannels[0][2] = GET_B(*prevPixel);
+    pixelChannels[1][0] = GET_R(*curPixel);
+    pixelChannels[1][1] = GET_G(*curPixel);
+    pixelChannels[1][2] = GET_B(*curPixel);
 
-    if (sp0[0][0] > 25 && sp0[0][1] > 25 && sp0[0][2] > 25)
-        return *a1;
-    if (sp0[1][0] > 25 && sp0[1][1] > 25 && sp0[1][2] > 25)
-        return *a1;
+    if (pixelChannels[0][0] > 25 && pixelChannels[0][1] > 25 && pixelChannels[0][2] > 25)
+        return *curPixel;
+    if (pixelChannels[1][0] > 25 && pixelChannels[1][1] > 25 && pixelChannels[1][2] > 25)
+        return *curPixel;
 
-    for (r4 = 0; r4 < 3; r4++)
+    for (i = 0; i < 3; i++)
     {
-        if (sp0[0][r4] > sp0[1][r4])
-            spC[r4] = sp0[0][r4] - sp0[1][r4];
+        if (pixelChannels[0][i] > pixelChannels[1][i])
+            diffs[i] = pixelChannels[0][i] - pixelChannels[1][i];
         else
-            spC[r4] = sp0[1][r4] - sp0[0][r4];
+            diffs[i] = pixelChannels[1][i] - pixelChannels[0][i];
     }
 
-    if (spC[0] >= spC[1])
+    if (diffs[0] >= diffs[1])
     {
-        if (spC[0] >= spC[2])
-            r2 = spC[0];
-        else if (spC[1] >= spC[2])
-            r2 = spC[1];
+        if (diffs[0] >= diffs[2])
+            largestDiff = diffs[0];
+        else if (diffs[1] >= diffs[2])
+            largestDiff = diffs[1];
         else
-            r2 = spC[2];
+            largestDiff = diffs[2];
     }
     else
     {
-        if (spC[1] >= spC[2])
-            r2 = spC[1];
-        else if (spC[2] >= spC[0])
-            r2 = spC[2];
+        if (diffs[1] >= diffs[2])
+            largestDiff = diffs[1];
+        else if (diffs[2] >= diffs[0])
+            largestDiff = diffs[2];
         else
-            r2 = spC[0];
+            largestDiff = diffs[0];
     }
 
-    r = (sp0[1][0] * (31 - r2 / 2)) / 31;
-    g = (sp0[1][1] * (31 - r2 / 2)) / 31;
-    b = (sp0[1][2] * (31 - r2 / 2)) / 31;
+    r = (pixelChannels[1][0] * (31 - largestDiff / 2)) / 31;
+    g = (pixelChannels[1][1] * (31 - largestDiff / 2)) / 31;
+    b = (pixelChannels[1][2] * (31 - largestDiff / 2)) / 31;
     return RGB2(r, g, b);
 }
 
-u16 sub_80FD68C(u16 * a0, u16 * a1, u16 * a2)
+u16 QuantizePixel_Blur(u16 *prevPixel, u16 *curPixel, u16 *nextPixel)
 {
     u16 red, green, blue;
     u16 avg0, avg1, avg2;
@@ -831,19 +677,19 @@ u16 sub_80FD68C(u16 * a0, u16 * a1, u16 * a2)
     u32 minimum;
     u16 factor;
 
-    if (*a0 == *a1 && *a2 == *a1)
-        return *a1;
+    if (*prevPixel == *curPixel && *nextPixel == *curPixel)
+        return *curPixel;
 
-    red = (*a1 >> 0) & 0x1F;
-    green = (*a1 >> 5) & 0x1F;
-    blue = (*a1 >> 10) & 0x1F;
+    red = GET_R(*curPixel);
+    green = GET_G(*curPixel);
+    blue = GET_B(*curPixel);
 
-    avg0 = (((*a0 >> 0) & 0x1F) + ((*a0 >> 5) & 0x1F) + ((*a0 >> 10) & 0x1F)) / 3;
-    avg1 = (((*a1 >> 0) & 0x1F) + ((*a1 >> 5) & 0x1F) + ((*a1 >> 10) & 0x1F)) / 3;
-    avg2 = (((*a2 >> 0) & 0x1F) + ((*a2 >> 5) & 0x1F) + ((*a2 >> 10) & 0x1F)) / 3;
+    avg0 = ((GET_R(*prevPixel)) + (GET_G(*prevPixel)) + (GET_B(*prevPixel))) / 3;
+    avg1 = ((GET_R(*curPixel)) + (GET_G(*curPixel)) + (GET_B(*curPixel))) / 3;
+    avg2 = ((GET_R(*nextPixel)) + (GET_G(*nextPixel)) + (GET_B(*nextPixel))) / 3;
 
     if (avg0 == avg1 && avg2 == avg1)
-        return *a1;
+        return *curPixel;
 
     if (avg0 > avg1)
         diff1 = avg0 - avg1;
@@ -867,7 +713,7 @@ u16 sub_80FD68C(u16 * a0, u16 * a1, u16 * a2)
     return RGB2(red, green, blue);
 }
 
-u16 sub_80FD7AC(u16 *a0, u16 *a1, u16 *a2)
+u16 QuantizePixel_BlurHard(u16 *prevPixel, u16 *curPixel, u16 *nextPixel)
 {
     u16 red, green, blue;
     u16 avg0, avg1, avg2;
@@ -875,19 +721,19 @@ u16 sub_80FD7AC(u16 *a0, u16 *a1, u16 *a2)
     u32 minimum;
     u16 factor;
 
-    if (*a0 == *a1 && *a2 == *a1)
-        return *a1;
+    if (*prevPixel == *curPixel && *nextPixel == *curPixel)
+        return *curPixel;
 
-    red = (*a1 >> 0) & 0x1F;
-    green = (*a1 >> 5) & 0x1F;
-    blue = (*a1 >> 10) & 0x1F;
+    red = GET_R(*curPixel);
+    green = GET_G(*curPixel);
+    blue = GET_B(*curPixel);
 
-    avg0 = (((*a0 >> 0) & 0x1F) + ((*a0 >> 5) & 0x1F) + ((*a0 >> 10) & 0x1F)) / 3;
-    avg1 = (((*a1 >> 0) & 0x1F) + ((*a1 >> 5) & 0x1F) + ((*a1 >> 10) & 0x1F)) / 3;
-    avg2 = (((*a2 >> 0) & 0x1F) + ((*a2 >> 5) & 0x1F) + ((*a2 >> 10) & 0x1F)) / 3;
+    avg0 = ((GET_R(*prevPixel)) + (GET_G(*prevPixel)) + (GET_B(*prevPixel))) / 3;
+    avg1 = ((GET_R(*curPixel)) + (GET_G(*curPixel)) + (GET_B(*curPixel))) / 3;
+    avg2 = ((GET_R(*nextPixel)) + (GET_G(*nextPixel)) + (GET_B(*nextPixel))) / 3;
 
     if (avg0 == avg1 && avg2 == avg1)
-        return *a1;
+        return *curPixel;
 
     if (avg0 > avg1)
         diff1 = avg0 - avg1;
@@ -911,318 +757,141 @@ u16 sub_80FD7AC(u16 *a0, u16 *a1, u16 *a2)
     return RGB2(red, green, blue);
 }
 
-/*
-void sub_80FD8CC(struct ImageProcessingContext * a0)
+void ConvertImageProcessingToGBA(struct ImageProcessingContext *context)
 {
     u16 i, j, k;
-    u8 r5 = a0->var_1D >> 3;
-    u8 sp08 = a0->var_1E >> 3;
-    u16 * sp00 = (u16 *)a0->var_4;
-    u16 * sp04 = (u16 *)a0->var_10;
-    if (a0->var_16 == 2)
+    u16 *src, *dest, *src_, *dest_;
+    u16 width, height;
+
+    width = context->canvasWidth >> 3;
+    height = context->canvasHeight >> 3;
+    src_ = context->canvasPixels;
+    dest_ = context->dest;
+
+    if (context->bgType == 2)
     {
-        for (i = 0; i < sp08; i++)
+        for (i = 0; i < height; i++)
         {
-            for (j = 0; j < r5; j++)
+            for (j = 0; j < width; j++)
             {
                 for (k = 0; k < 8; k++)
                 {
-                    u16 * r3 = &sp04[i * r5 * 32 + 4 * k];
-                    u16 * r2 = &sp00[j * 8 + (i * 8 + k) * 8 * r5];
-                    r3[0] = r2[0] | (r2[1] << 8);
-                    r3[1] = r2[2] | (r2[3] << 8);
-                    r3[2] = r2[4] | (r2[5] << 8);
-                    r3[3] = r2[6] | (r2[7] << 8);
+                    dest = dest_ + ((i * width + j) << 5) + (k << 2);
+                    src = src_ + ((((i << 3) + k) << 3) * width) + (j << 3);
+
+                    dest[0] = src[0] | (src[1] << 8);
+                    dest[1] = src[2] | (src[3] << 8);
+                    dest[2] = src[4] | (src[5] << 8);
+                    dest[3] = src[6] | (src[7] << 8);
                 }
             }
         }
     }
     else
     {
-        for (i = 0; i < sp08; i++)
+        for (i = 0; i < height; i++)
         {
-            for (j = 0; j < r5; j++)
+            for (j = 0; j < width; j++)
             {
                 for (k = 0; k < 8; k++)
                 {
-                    u16 * r3 = &sp04[i * r5 * 16 + 2 * k];
-                    u16 * r2 = &sp00[j * 8 + (i * 8 + k) * 8 * r5];
-                    r3[0] = r2[0] | (r2[1] << 4) | (r2[2] << 8) | (r2[3] << 12);
-                    r3[1] = r2[4] | (r2[5] << 4) | (r2[6] << 8) | (r2[7] << 12);
+                    dest = dest_ + ((i * width + j) << 4) + (k << 1);
+                    src = src_ + ((((i << 3) + k) << 3) * width) + (j << 3);
+
+                    dest[0] = src[0] | (src[1] << 4) | (src[2] << 8) | (src[3] << 12);
+                    dest[1] = src[4] | (src[5] << 4) | (src[6] << 8) | (src[7] << 12);
                 }
             }
         }
     }
 }
-*/
-
-NAKED
-void sub_80FD8CC(struct ImageProcessingContext * a0)
-{
-    asm_unified("\tpush {r4-r7,lr}\n"
-                "\tmov r7, r10\n"
-                "\tmov r6, r9\n"
-                "\tmov r5, r8\n"
-                "\tpush {r5-r7}\n"
-                "\tsub sp, 0xC\n"
-                "\tldrb r1, [r0, 0x1D]\n"
-                "\tlsrs r5, r1, 3\n"
-                "\tldrb r1, [r0, 0x1E]\n"
-                "\tlsrs r1, 3\n"
-                "\tstr r1, [sp, 0x8]\n"
-                "\tldr r1, [r0, 0x4]\n"
-                "\tstr r1, [sp]\n"
-                "\tldr r2, [r0, 0x10]\n"
-                "\tstr r2, [sp, 0x4]\n"
-                "\tldrh r0, [r0, 0x16]\n"
-                "\tcmp r0, 0x2\n"
-                "\tbne _080FD97C\n"
-                "\tmovs r1, 0\n"
-                "\tldr r0, [sp, 0x8]\n"
-                "\tcmp r1, r0\n"
-                "\tbcc _080FD8FA\n"
-                "\tb _080FDA08\n"
-                "_080FD8FA:\n"
-                "\tmovs r0, 0\n"
-                "\tadds r2, r1, 0x1\n"
-                "\tmov r10, r2\n"
-                "\tcmp r0, r5\n"
-                "\tbcs _080FD96E\n"
-                "\tadds r2, r1, 0\n"
-                "\tmuls r2, r5\n"
-                "\tmov r9, r2\n"
-                "\tlsls r1, 3\n"
-                "\tmov r8, r1\n"
-                "_080FD90E:\n"
-                "\tmovs r4, 0\n"
-                "\tlsls r6, r0, 4\n"
-                "\tadds r7, r0, 0x1\n"
-                "\tadd r0, r9\n"
-                "\tlsls r0, 6\n"
-                "\tldr r1, [sp, 0x4]\n"
-                "\tadds r1, r0\n"
-                "\tmov r12, r1\n"
-                "_080FD91E:\n"
-                "\tlsls r0, r4, 3\n"
-                "\tmov r2, r12\n"
-                "\tadds r3, r2, r0\n"
-                "\tmov r1, r8\n"
-                "\tadds r0, r1, r4\n"
-                "\tlsls r0, 3\n"
-                "\tmuls r0, r5\n"
-                "\tlsls r0, 1\n"
-                "\tldr r2, [sp]\n"
-                "\tadds r0, r2, r0\n"
-                "\tadds r2, r0, r6\n"
-                "\tldrh r0, [r2, 0x2]\n"
-                "\tlsls r0, 8\n"
-                "\tldrh r1, [r2]\n"
-                "\torrs r0, r1\n"
-                "\tstrh r0, [r3]\n"
-                "\tldrh r0, [r2, 0x6]\n"
-                "\tlsls r0, 8\n"
-                "\tldrh r1, [r2, 0x4]\n"
-                "\torrs r0, r1\n"
-                "\tstrh r0, [r3, 0x2]\n"
-                "\tldrh r0, [r2, 0xA]\n"
-                "\tlsls r0, 8\n"
-                "\tldrh r1, [r2, 0x8]\n"
-                "\torrs r0, r1\n"
-                "\tstrh r0, [r3, 0x4]\n"
-                "\tldrh r0, [r2, 0xE]\n"
-                "\tlsls r0, 8\n"
-                "\tldrh r1, [r2, 0xC]\n"
-                "\torrs r0, r1\n"
-                "\tstrh r0, [r3, 0x6]\n"
-                "\tadds r0, r4, 0x1\n"
-                "\tlsls r0, 16\n"
-                "\tlsrs r4, r0, 16\n"
-                "\tcmp r4, 0x7\n"
-                "\tbls _080FD91E\n"
-                "\tlsls r0, r7, 16\n"
-                "\tlsrs r0, 16\n"
-                "\tcmp r0, r5\n"
-                "\tbcc _080FD90E\n"
-                "_080FD96E:\n"
-                "\tmov r1, r10\n"
-                "\tlsls r0, r1, 16\n"
-                "\tlsrs r1, r0, 16\n"
-                "\tldr r2, [sp, 0x8]\n"
-                "\tcmp r1, r2\n"
-                "\tbcc _080FD8FA\n"
-                "\tb _080FDA08\n"
-                "_080FD97C:\n"
-                "\tmovs r1, 0\n"
-                "\tldr r0, [sp, 0x8]\n"
-                "\tcmp r1, r0\n"
-                "\tbcs _080FDA08\n"
-                "_080FD984:\n"
-                "\tmovs r0, 0\n"
-                "\tadds r2, r1, 0x1\n"
-                "\tmov r10, r2\n"
-                "\tcmp r0, r5\n"
-                "\tbcs _080FD9FC\n"
-                "\tadds r2, r1, 0\n"
-                "\tmuls r2, r5\n"
-                "\tmov r9, r2\n"
-                "\tlsls r1, 3\n"
-                "\tmov r8, r1\n"
-                "_080FD998:\n"
-                "\tmovs r4, 0\n"
-                "\tlsls r6, r0, 4\n"
-                "\tadds r7, r0, 0x1\n"
-                "\tadd r0, r9\n"
-                "\tlsls r0, 5\n"
-                "\tldr r1, [sp, 0x4]\n"
-                "\tadds r1, r0\n"
-                "\tmov r12, r1\n"
-                "_080FD9A8:\n"
-                "\tlsls r0, r4, 2\n"
-                "\tmov r2, r12\n"
-                "\tadds r3, r2, r0\n"
-                "\tmov r1, r8\n"
-                "\tadds r0, r1, r4\n"
-                "\tlsls r0, 3\n"
-                "\tmuls r0, r5\n"
-                "\tlsls r0, 1\n"
-                "\tldr r2, [sp]\n"
-                "\tadds r0, r2, r0\n"
-                "\tadds r2, r0, r6\n"
-                "\tldrh r1, [r2, 0x2]\n"
-                "\tlsls r1, 4\n"
-                "\tldrh r0, [r2]\n"
-                "\torrs r1, r0\n"
-                "\tldrh r0, [r2, 0x4]\n"
-                "\tlsls r0, 8\n"
-                "\torrs r1, r0\n"
-                "\tldrh r0, [r2, 0x6]\n"
-                "\tlsls r0, 12\n"
-                "\torrs r1, r0\n"
-                "\tstrh r1, [r3]\n"
-                "\tldrh r1, [r2, 0xA]\n"
-                "\tlsls r1, 4\n"
-                "\tldrh r0, [r2, 0x8]\n"
-                "\torrs r1, r0\n"
-                "\tldrh r0, [r2, 0xC]\n"
-                "\tlsls r0, 8\n"
-                "\torrs r1, r0\n"
-                "\tldrh r0, [r2, 0xE]\n"
-                "\tlsls r0, 12\n"
-                "\torrs r1, r0\n"
-                "\tstrh r1, [r3, 0x2]\n"
-                "\tadds r0, r4, 0x1\n"
-                "\tlsls r0, 16\n"
-                "\tlsrs r4, r0, 16\n"
-                "\tcmp r4, 0x7\n"
-                "\tbls _080FD9A8\n"
-                "\tlsls r0, r7, 16\n"
-                "\tlsrs r0, 16\n"
-                "\tcmp r0, r5\n"
-                "\tbcc _080FD998\n"
-                "_080FD9FC:\n"
-                "\tmov r1, r10\n"
-                "\tlsls r0, r1, 16\n"
-                "\tlsrs r1, r0, 16\n"
-                "\tldr r2, [sp, 0x8]\n"
-                "\tcmp r1, r2\n"
-                "\tbcc _080FD984\n"
-                "_080FDA08:\n"
-                "\tadd sp, 0xC\n"
-                "\tpop {r3-r5}\n"
-                "\tmov r8, r3\n"
-                "\tmov r9, r4\n"
-                "\tmov r10, r5\n"
-                "\tpop {r4-r7}\n"
-                "\tpop {r0}\n"
-                "\tbx r0");
-}
 
-void sub_80FDA18(struct ImageProcessingContext *arg0)
+void ApplyImageProcessingQuantization(struct ImageProcessingContext *arg0)
 {
-    gUnknown_03005E0C = arg0->var_18 * 16;
-    gUnknown_03005E08 = &arg0->var_8[gUnknown_03005E0C];
-    gUnknown_03005DEC = arg0->var_4;
-    gUnknown_03005DE8 = arg0->var_19;
-    gUnknown_03005DFC = arg0->var_1A;
-    gUnknown_03005DF8 = arg0->var_1B;
-    gUnknown_03005DF0 = arg0->var_1C;
-    gUnknown_03005E04 = arg0->var_1D;
-    gUnknown_03005DF4 = arg0->var_1E;
-
-    switch (arg0->var_14)
+    gCanvasPaletteStart = arg0->paletteStart * 16;
+    gCanvasPalette = &arg0->canvasPalette[gCanvasPaletteStart];
+    gCanvasPixels = arg0->canvasPixels;
+    gCanvasColumnStart = arg0->columnStart;
+    gCanvasRowStart = arg0->rowStart;
+    gCanvasColumnEnd = arg0->columnEnd;
+    gCanvasRowEnd = arg0->rowEnd;
+    gCanvasWidth = arg0->canvasWidth;
+    gCanvasHeight = arg0->canvasHeight;
+
+    switch (arg0->quantizeEffect)
     {
-    case 0:
-        sub_80FDC18(FALSE);
+    case QUANTIZE_EFFECT_STANDARD:
+        QuantizePalette_Standard(FALSE);
         break;
-    case 1:
-        sub_80FDC18(TRUE);
+    case QUANTIZE_EFFECT_STANDARD_LIMITED_COLORS:
+        QuantizePalette_Standard(TRUE);
         break;
-    case 2:
-        sub_80FDAE4();
-        sub_80FDF88();
+    case QUANTIZE_EFFECT_PRIMARY_COLORS:
+        SetPresetPalette_PrimaryColors();
+        QuantizePalette_PrimaryColors();
         break;
-    case 3:
-        sub_80FDBE4();
-        sub_80FDED8();
+    case QUANTIZE_EFFECT_GRAYSCALE:
+        SetPresetPalette_Grayscale();
+        QuantizePalette_Grayscale();
         break;
-    case 4:
-        sub_80FDBA8();
-        sub_80FDE28();
+    case QUANTIZE_EFFECT_GRAYSCALE_SMALL:
+        SetPresetPalette_GrayscaleSmall();
+        QuantizePalette_GrayscaleSmall();
         break;
-    case 5:
-        sub_80FDB8C();
-        sub_80FDD70();
+    case QUANTIZE_EFFECT_BLACK_WHITE:
+        SetPresetPalette_BlackAndWhite();
+        QuantizePalette_BlackAndWhite();
         break;
     }
 }
 
-void sub_80FDAE4(void)
+void SetPresetPalette_PrimaryColors(void)
 {
-    gUnknown_03005E08[0] = RGB2(0, 0, 0);
-    gUnknown_03005E08[1] = RGB2(6, 6, 6);
-    gUnknown_03005E08[2] = RGB2(29, 29, 29);
-    gUnknown_03005E08[3] = RGB2(11, 11, 11);
-    gUnknown_03005E08[4] = RGB2(29, 6, 6);
-    gUnknown_03005E08[5] = RGB2(6, 29, 6);
-    gUnknown_03005E08[6] = RGB2(6, 6, 29);
-    gUnknown_03005E08[7] = RGB2(29, 29, 6);
-    gUnknown_03005E08[8] = RGB2(29, 6, 29);
-    gUnknown_03005E08[9] = RGB2(6, 29, 29);
-    gUnknown_03005E08[10] = RGB2(29, 11, 6);
-    gUnknown_03005E08[11] = RGB2(11, 29, 6);
-    gUnknown_03005E08[12] = RGB2(6, 11, 29);
-    gUnknown_03005E08[13] = RGB2(29, 6, 11);
-    gUnknown_03005E08[14] = RGB2(6, 29, 11);
-    gUnknown_03005E08[15] = RGB2(11, 6, 29);
+    gCanvasPalette[0] = RGB_BLACK;
+    gCanvasPalette[1] = RGB2(6, 6, 6);
+    gCanvasPalette[2] = RGB2(29, 29, 29);
+    gCanvasPalette[3] = RGB2(11, 11, 11);
+    gCanvasPalette[4] = RGB2(29, 6, 6);
+    gCanvasPalette[5] = RGB2(6, 29, 6);
+    gCanvasPalette[6] = RGB2(6, 6, 29);
+    gCanvasPalette[7] = RGB2(29, 29, 6);
+    gCanvasPalette[8] = RGB2(29, 6, 29);
+    gCanvasPalette[9] = RGB2(6, 29, 29);
+    gCanvasPalette[10] = RGB2(29, 11, 6);
+    gCanvasPalette[11] = RGB2(11, 29, 6);
+    gCanvasPalette[12] = RGB2(6, 11, 29);
+    gCanvasPalette[13] = RGB2(29, 6, 11);
+    gCanvasPalette[14] = RGB2(6, 29, 11);
+    gCanvasPalette[15] = RGB2(11, 6, 29);
 }
 
-void sub_80FDB8C(void)
+void SetPresetPalette_BlackAndWhite(void)
 {
-    gUnknown_03005E08[0] = RGB2(0, 0, 0);
-    gUnknown_03005E08[1] = RGB2(0, 0, 0);
-    gUnknown_03005E08[2] = RGB2(31, 31, 31);
+    gCanvasPalette[0] = RGB_BLACK;
+    gCanvasPalette[1] = RGB_BLACK;
+    gCanvasPalette[2] = RGB_WHITE;
 }
 
-void sub_80FDBA8(void)
+void SetPresetPalette_GrayscaleSmall(void)
 {
     u8 i;
 
-    gUnknown_03005E08[0] = RGB2(0, 0, 0);
-    gUnknown_03005E08[1] = RGB2(0, 0, 0);
+    gCanvasPalette[0] = RGB_BLACK;
+    gCanvasPalette[1] = RGB_BLACK;
     for (i = 0; i < 14; i++)
-        gUnknown_03005E08[i + 2] = RGB2(2 * (i + 2), 2 * (i + 2), 2 * (i + 2));
+        gCanvasPalette[i + 2] = RGB2(2 * (i + 2), 2 * (i + 2), 2 * (i + 2));
 }
 
-void sub_80FDBE4(void)
+void SetPresetPalette_Grayscale(void)
 {
     u8 i;
 
-    gUnknown_03005E08[0] = RGB2(0, 0, 0);
+    gCanvasPalette[0] = RGB_BLACK;
     for (i = 0; i < 32; i++)
-        gUnknown_03005E08[i + 1] = RGB2(i, i, i);
+        gCanvasPalette[i + 1] = RGB2(i, i, i);
 }
 
-void sub_80FDC18(bool8 arg0)
+void QuantizePalette_Standard(bool8 arg0)
 {
     u8 i, j;
     u16 maxIndex;
@@ -1232,44 +901,44 @@ void sub_80FDC18(bool8 arg0)
         maxIndex = 0xFF;
 
     for (j = 0; j < maxIndex; j++)
-        gUnknown_03005E08[j] = 0;
+        gCanvasPalette[j] = 0;
 
-    gUnknown_03005E08[maxIndex] = RGB2(15, 15, 15);
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    gCanvasPalette[maxIndex] = RGB2(15, 15, 15);
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (*pal & 0x8000)
+            if (IS_ALPHA(*pal))
             {
-                *pal = gUnknown_03005E0C;
+                *pal = gCanvasPaletteStart;
             }
             else
             {
-                u16 color = sub_80FE038(pal);
+                u16 color = QuantizePixel_Standard(pal);
                 u8 curIndex = 1;
                 if (curIndex < maxIndex)
                 {
-                    if (gUnknown_03005E08[curIndex] == RGB_BLACK)
+                    if (gCanvasPalette[curIndex] == RGB_BLACK)
                     {
-                        gUnknown_03005E08[curIndex] = color;
-                        *pal = gUnknown_03005E0C + curIndex;
+                        gCanvasPalette[curIndex] = color;
+                        *pal = gCanvasPaletteStart + curIndex;
                     }
                     else
                     {
                         while (curIndex < maxIndex)
                         {
-                            if (gUnknown_03005E08[curIndex] == RGB_BLACK)
+                            if (gCanvasPalette[curIndex] == RGB_BLACK)
                             {
-                                gUnknown_03005E08[curIndex] = color;
-                                *pal = gUnknown_03005E0C + curIndex;
+                                gCanvasPalette[curIndex] = color;
+                                *pal = gCanvasPaletteStart + curIndex;
                                 break;
                             }
 
-                            if (gUnknown_03005E08[curIndex] == color)
+                            if (gCanvasPalette[curIndex] == color)
                             {
-                                *pal = gUnknown_03005E0C + curIndex;
+                                *pal = gCanvasPaletteStart + curIndex;
                                 break;
                             }
 
@@ -1288,90 +957,90 @@ void sub_80FDC18(bool8 arg0)
     }
 }
 
-void sub_80FDD70(void)
+void QuantizePalette_BlackAndWhite(void)
 {
     u8 i, j;
 
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (*pal & 0x8000)
+            if (IS_ALPHA(*pal))
             {
-                *pal = gUnknown_03005E0C;
+                *pal = gCanvasPaletteStart;
             }
             else
             {
-                if (ConvertToBlackOrWhite(pal) == RGB_BLACK)
-                    *pal = gUnknown_03005E0C + 1;
+                if (QuantizePixel_BlackAndWhite(pal) == RGB_BLACK)
+                    *pal = gCanvasPaletteStart + 1;
                 else
-                    *pal = gUnknown_03005E0C + 2;
+                    *pal = gCanvasPaletteStart + 2;
             }
         }
     }
 }
 
-void sub_80FDE28(void)
+void QuantizePalette_GrayscaleSmall(void)
 {
     u8 i, j;
 
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (*pal & 0x8000)
-                *pal = gUnknown_03005E0C;
+            if (IS_ALPHA(*pal))
+                *pal = gCanvasPaletteStart;
             else
-                *pal = sub_80FE17C(pal) + gUnknown_03005E0C;
+                *pal = QuantizePixel_GrayscaleSmall(pal) + gCanvasPaletteStart;
         }
     }
 }
 
-void sub_80FDED8(void)
+void QuantizePalette_Grayscale(void)
 {
     u8 i, j;
 
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (*pal & 0x8000)
-                *pal = gUnknown_03005E0C;
+            if (IS_ALPHA(*pal))
+                *pal = gCanvasPaletteStart;
             else
-                *pal = sub_80FE1B0(pal) + gUnknown_03005E0C;
+                *pal = QuantizePixel_Grayscale(pal) + gCanvasPaletteStart;
         }
     }
 }
 
-void sub_80FDF88(void)
+void QuantizePalette_PrimaryColors(void)
 {
     u8 i, j;
 
-    for (i = 0; i < gUnknown_03005DF0; i++)
+    for (i = 0; i < gCanvasRowEnd; i++)
     {
-        u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04];
-        u16* pal = &var2[gUnknown_03005DE8];
-        for (j = 0; j < gUnknown_03005DF8; j++, pal++)
+        u16* var2 = &gCanvasPixels[(gCanvasRowStart + i) * gCanvasWidth];
+        u16* pal = &var2[gCanvasColumnStart];
+        for (j = 0; j < gCanvasColumnEnd; j++, pal++)
         {
-            if (*pal & 0x8000)
-                *pal = gUnknown_03005E0C;
+            if (IS_ALPHA(*pal))
+                *pal = gCanvasPaletteStart;
             else
-                *pal = sub_80FE0AC(pal) + gUnknown_03005E0C;
+                *pal = QuantizePixel_PrimaryColors(pal) + gCanvasPaletteStart;
         }
     }
 }
 
-u16 sub_80FE038(u16 *color)
+u16 QuantizePixel_Standard(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
 
     if (red & 3)
         red = (red & 0x1C) + 4;
@@ -1398,11 +1067,11 @@ u16 sub_80FE038(u16 *color)
     return RGB2(red, green, blue);
 }
 
-u16 sub_80FE0AC(u16* color)
+u16 QuantizePixel_PrimaryColors(u16* color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
 
     if (red < 12 && green < 11 && blue < 11)
         return 1;
@@ -1513,11 +1182,11 @@ u16 sub_80FE0AC(u16* color)
     return 3;
 }
 
-u16 sub_80FE17C(u16 *color)
+u16 QuantizePixel_GrayscaleSmall(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     u16 average = ((red + green + blue) / 3) & 0x1E;
     if (average == 0)
         return 1;
@@ -1525,11 +1194,11 @@ u16 sub_80FE17C(u16 *color)
         return average / 2;
 }
 
-u16 sub_80FE1B0(u16 *color)
+u16 QuantizePixel_Grayscale(u16 *color)
 {
-    u16 red = *color & 0x1F;
-    u16 green = (*color >> 5) & 0x1F;
-    u16 blue = (*color >> 10) & 0x1F;
+    u16 red = GET_R(*color);
+    u16 green = GET_G(*color);
+    u16 blue = GET_B(*color);
     u16 average = (red + green + blue) / 3;
     return average + 1;
 }