Converted most types to stdint-style (fixing a few in the process).

1 files changed, 403 insertions, 415 deletions

diff --git a/source/clip.c b/source/clip.c
index 7931101..1a52bea 100644
--- a/source/clip.c
+++ b/source/clip.c
@@ -23,7 +23,7 @@ struct Band
     R.Left = MAX(A.Left, B.Left); \
       R.Right = MIN(A.Right, B.Right);}
 
-static int IntCompare(const void* d1, const void* d2)
+static int32_t IntCompare(const void* d1, const void* d2)
 {
    if (*(uint32_t*) d1 > *(uint32_t*) d2)
       return (1);
@@ -32,7 +32,7 @@ static int IntCompare(const void* d1, const void* d2)
    return (0);
 }
 
-static int BandCompare(const void* d1, const void* d2)
+static int32_t BandCompare(const void* d1, const void* d2)
 {
    if (((struct Band*) d1)->Left > ((struct Band*) d2)->Left)
       return (1);
@@ -44,7 +44,7 @@ static int BandCompare(const void* d1, const void* d2)
 void ComputeClipWindows()
 {
    struct ClipData* pClip = &IPPU.Clip [0];
-   int c, w, i;
+   int32_t c, w, i;
 
    // Loop around the main screen then the sub-screen.
    for (c = 0; c < 2; c++, pClip++)
@@ -81,7 +81,7 @@ void ComputeClipWindows()
                {
                   // The sub-screen is switched off, completely
                   // clip everything.
-                  int i;
+                  int32_t i;
                   for (i = 0; i < 6; i++)
                   {
                      IPPU.Clip [1].Count [i] = 1;
@@ -95,578 +95,566 @@ void ComputeClipWindows()
             }
          }
 
+         if (w == 5 || pClip->Count [5] ||
+               (Memory.FillRAM [0x212c + c] & Memory.FillRAM [0x212e + c] & (1 << w)))
          {
-            if (w == 5 || pClip->Count [5] ||
+            struct Band Win1[3];
+            struct Band Win2[3];
+            uint32_t Window1Enabled = 0;
+            uint32_t Window2Enabled = 0;
+            bool invert = (w == 5 &&
+                            ((c == 1 && (Memory.FillRAM [0x2130] & 0x30) == 0x10) ||
+                             (c == 0 && (Memory.FillRAM [0x2130] & 0xc0) == 0x40)));
+
+            if (w == 5 ||
                   (Memory.FillRAM [0x212c + c] & Memory.FillRAM [0x212e + c] & (1 << w)))
             {
-               struct Band Win1[3];
-               struct Band Win2[3];
-               uint32_t Window1Enabled = 0;
-               uint32_t Window2Enabled = 0;
-               bool invert = (w == 5 &&
-                               ((c == 1 && (Memory.FillRAM [0x2130] & 0x30) == 0x10) ||
-                                (c == 0 && (Memory.FillRAM [0x2130] & 0xc0) == 0x40)));
-
-               if (w == 5 ||
-                     (Memory.FillRAM [0x212c + c] & Memory.FillRAM [0x212e + c] & (1 << w)))
+               if (PPU.ClipWindow1Enable [w])
                {
-                  if (PPU.ClipWindow1Enable [w])
+                  if (!PPU.ClipWindow1Inside [w])
                   {
-                     if (!PPU.ClipWindow1Inside [w])
-                     {
-                        Win1[Window1Enabled].Left = PPU.Window1Left;
-                        Win1[Window1Enabled++].Right = PPU.Window1Right + 1;
-                     }
-                     else
+                     Win1[Window1Enabled].Left = PPU.Window1Left;
+                     Win1[Window1Enabled++].Right = PPU.Window1Right + 1;
+                  }
+                  else
+                  {
+                     if (PPU.Window1Left <= PPU.Window1Right)
                      {
-                        if (PPU.Window1Left <= PPU.Window1Right)
+                        if (PPU.Window1Left > 0)
                         {
-                           if (PPU.Window1Left > 0)
-                           {
-                              Win1[Window1Enabled].Left = 0;
-                              Win1[Window1Enabled++].Right = PPU.Window1Left;
-                           }
-                           if (PPU.Window1Right < 255)
-                           {
-                              Win1[Window1Enabled].Left = PPU.Window1Right + 1;
-                              Win1[Window1Enabled++].Right = 256;
-                           }
-                           if (Window1Enabled == 0)
-                           {
-                              Win1[Window1Enabled].Left = 1;
-                              Win1[Window1Enabled++].Right = 0;
-                           }
+                           Win1[Window1Enabled].Left = 0;
+                           Win1[Window1Enabled++].Right = PPU.Window1Left;
                         }
-                        else
+                        if (PPU.Window1Right < 255)
                         {
-                           // 'outside' a window with no range -
-                           // appears to be the whole screen.
-                           Win1[Window1Enabled].Left = 0;
+                           Win1[Window1Enabled].Left = PPU.Window1Right + 1;
                            Win1[Window1Enabled++].Right = 256;
                         }
+                        if (Window1Enabled == 0)
+                        {
+                           Win1[Window1Enabled].Left = 1;
+                           Win1[Window1Enabled++].Right = 0;
+                        }
                      }
-                  }
-                  if (PPU.ClipWindow2Enable [w])
-                  {
-                     if (!PPU.ClipWindow2Inside [w])
+                     else
                      {
-                        Win2[Window2Enabled].Left = PPU.Window2Left;
-                        Win2[Window2Enabled++].Right = PPU.Window2Right + 1;
+                        // 'outside' a window with no range -
+                        // appears to be the whole screen.
+                        Win1[Window1Enabled].Left = 0;
+                        Win1[Window1Enabled++].Right = 256;
                      }
-                     else
+                  }
+               }
+               if (PPU.ClipWindow2Enable [w])
+               {
+                  if (!PPU.ClipWindow2Inside [w])
+                  {
+                     Win2[Window2Enabled].Left = PPU.Window2Left;
+                     Win2[Window2Enabled++].Right = PPU.Window2Right + 1;
+                  }
+                  else
+                  {
+                     if (PPU.Window2Left <= PPU.Window2Right)
                      {
-                        if (PPU.Window2Left <= PPU.Window2Right)
+                        if (PPU.Window2Left > 0)
                         {
-                           if (PPU.Window2Left > 0)
-                           {
-                              Win2[Window2Enabled].Left = 0;
-                              Win2[Window2Enabled++].Right = PPU.Window2Left;
-                           }
-                           if (PPU.Window2Right < 255)
-                           {
-                              Win2[Window2Enabled].Left = PPU.Window2Right + 1;
-                              Win2[Window2Enabled++].Right = 256;
-                           }
-                           if (Window2Enabled == 0)
-                           {
-                              Win2[Window2Enabled].Left = 1;
-                              Win2[Window2Enabled++].Right = 0;
-                           }
+                           Win2[Window2Enabled].Left = 0;
+                           Win2[Window2Enabled++].Right = PPU.Window2Left;
                         }
-                        else
+                        if (PPU.Window2Right < 255)
                         {
-                           Win2[Window2Enabled].Left = 0;
+                           Win2[Window2Enabled].Left = PPU.Window2Right + 1;
                            Win2[Window2Enabled++].Right = 256;
                         }
+                        if (Window2Enabled == 0)
+                        {
+                           Win2[Window2Enabled].Left = 1;
+                           Win2[Window2Enabled++].Right = 0;
+                        }
+                     }
+                     else
+                     {
+                        Win2[Window2Enabled].Left = 0;
+                        Win2[Window2Enabled++].Right = 256;
                      }
                   }
                }
-               if (Window1Enabled && Window2Enabled)
+            }
+            if (Window1Enabled && Window2Enabled)
+            {
+               // Overlap logic
+               //
+               // Each window will be in one of three states:
+               // 1. <no range> (Left > Right. One band)
+               // 2. |    ----------------             | (Left >= 0, Right <= 255, Left <= Right. One band)
+               // 3. |------------           ----------| (Left1 == 0, Right1 < Left2; Left2 > Right1, Right2 == 255. Two bands)
+               struct Band Bands [6];
+               int32_t B = 0;
+               switch (PPU.ClipWindowOverlapLogic [w] ^ 1)
                {
-                  // Overlap logic
-                  //
-                  // Each window will be in one of three states:
-                  // 1. <no range> (Left > Right. One band)
-                  // 2. |    ----------------             | (Left >= 0, Right <= 255, Left <= Right. One band)
-                  // 3. |------------           ----------| (Left1 == 0, Right1 < Left2; Left2 > Right1, Right2 == 255. Two bands)
-
-                  struct Band Bands [6];
-                  int B = 0;
-                  switch (PPU.ClipWindowOverlapLogic [w] ^ 1)
+               case CLIP_OR:
+                  if (Window1Enabled == 1)
                   {
-                  case CLIP_OR:
-                     if (Window1Enabled == 1)
+                     if (BAND_EMPTY(Win1[0]))
                      {
-                        if (BAND_EMPTY(Win1[0]))
-                        {
-                           B = Window2Enabled;
-                           // memmove converted: Different stack allocations [Neb]
-                           memcpy(Bands, Win2,
-                                  sizeof(Win2[0]) * Window2Enabled);
-                        }
-                        else
+                        B = Window2Enabled;
+                        // memmove converted: Different stack allocations [Neb]
+                        memcpy(Bands, Win2, sizeof(Win2[0]) * Window2Enabled);
+                     }
+                     else
+                     {
+                        if (Window2Enabled == 1)
                         {
-                           if (Window2Enabled == 1)
-                           {
-                              if (BAND_EMPTY(Win2[0]))
-                                 Bands[B++] = Win1[0];
-                              else
-                              {
-                                 if (BANDS_INTERSECT(Win1[0], Win2[0]))
-                                 {
-                                    OR_BANDS(Bands[0], Win1[0], Win2[0])
-                                    B = 1;
-                                 }
-                                 else
-                                 {
-                                    Bands[B++] = Win1[0];
-                                    Bands[B++] = Win2[0];
-                                 }
-                              }
-                           }
+                           if (BAND_EMPTY(Win2[0]))
+                              Bands[B++] = Win1[0];
                            else
                            {
                               if (BANDS_INTERSECT(Win1[0], Win2[0]))
                               {
                                  OR_BANDS(Bands[0], Win1[0], Win2[0])
-                                 if (BANDS_INTERSECT(Win1[0], Win2[1]))
-                                    OR_BANDS(Bands[1], Win1[0], Win2[1])
-                                    else
-                                       Bands[1] = Win2[1];
                                  B = 1;
-                                 if (BANDS_INTERSECT(Bands[0], Bands[1]))
-                                    OR_BANDS(Bands[0], Bands[0], Bands[1])
-                                    else
-                                       B = 2;
-                              }
-                              else if (BANDS_INTERSECT(Win1[0], Win2[1]))
-                              {
-                                 Bands[B++] = Win2[0];
-                                 OR_BANDS(Bands[B], Win1[0], Win2[1]);
-                                 B++;
                               }
                               else
                               {
-                                 Bands[0] = Win2[0];
-                                 Bands[1] = Win1[0];
-                                 Bands[2] = Win2[1];
-                                 B = 3;
+                                 Bands[B++] = Win1[0];
+                                 Bands[B++] = Win2[0];
                               }
                            }
                         }
-                     }
-                     else if (Window2Enabled == 1)
-                     {
-                        if (BAND_EMPTY(Win2[0]))
-                        {
-                           // Window 2 defines an empty range - just
-                           // use window 1 as the clipping (which
-                           // could also be empty).
-                           B = Window1Enabled;
-                           // memmove converted: Different stack allocations [Neb]
-                           memcpy(Bands, Win1,
-                                  sizeof(Win1[0]) * Window1Enabled);
-                        }
                         else
                         {
-                           // Window 1 has two bands and Window 2 has one.
-                           // Neither is an empty region.
-                           if (BANDS_INTERSECT(Win2[0], Win1[0]))
+                           if (BANDS_INTERSECT(Win1[0], Win2[0]))
                            {
-                              OR_BANDS(Bands[0], Win2[0], Win1[0])
-                              if (BANDS_INTERSECT(Win2[0], Win1[1]))
-                                 OR_BANDS(Bands[1], Win2[0], Win1[1])
-                                 else
-                                    Bands[1] = Win1[1];
+                              OR_BANDS(Bands[0], Win1[0], Win2[0])
+                              if (BANDS_INTERSECT(Win1[0], Win2[1]))
+                                 OR_BANDS(Bands[1], Win1[0], Win2[1])
+                              else
+                                 Bands[1] = Win2[1];
                               B = 1;
                               if (BANDS_INTERSECT(Bands[0], Bands[1]))
                                  OR_BANDS(Bands[0], Bands[0], Bands[1])
-                                 else
-                                    B = 2;
+                              else
+                                 B = 2;
                            }
-                           else if (BANDS_INTERSECT(Win2[0], Win1[1]))
+                           else if (BANDS_INTERSECT(Win1[0], Win2[1]))
                            {
-                              Bands[B++] = Win1[0];
-                              OR_BANDS(Bands[B], Win2[0], Win1[1]);
+                              Bands[B++] = Win2[0];
+                              OR_BANDS(Bands[B], Win1[0], Win2[1]);
                               B++;
                            }
                            else
                            {
-                              Bands[0] = Win1[0];
-                              Bands[1] = Win2[0];
-                              Bands[2] = Win1[1];
+                              Bands[0] = Win2[0];
+                              Bands[1] = Win1[0];
+                              Bands[2] = Win2[1];
                               B = 3;
                            }
                         }
                      }
-                     else
+                  }
+                  else if (Window2Enabled == 1)
+                  {
+                     if (BAND_EMPTY(Win2[0]))
                      {
-                        // Both windows have two bands
-                        OR_BANDS(Bands[0], Win1[0], Win2[0]);
-                        OR_BANDS(Bands[1], Win1[1], Win2[1]);
-                        B = 1;
-                        if (BANDS_INTERSECT(Bands[0], Bands[1]))
-                           OR_BANDS(Bands[0], Bands[0], Bands[1])
-                           else
-                              B = 2;
+                        // Window 2 defines an empty range - just
+                        // use window 1 as the clipping (which
+                        // could also be empty).
+                        B = Window1Enabled;
+                        // memmove converted: Different stack allocations [Neb]
+                        memcpy(Bands, Win1, sizeof(Win1[0]) * Window1Enabled);
                      }
-                     break;
-
-                  case CLIP_AND:
-                     if (Window1Enabled == 1)
+                     else
                      {
-                        // Window 1 has one band
-                        if (BAND_EMPTY(Win1[0]))
-                           Bands [B++] = Win1[0];
-                        else if (Window2Enabled == 1)
+                        // Window 1 has two bands and Window 2 has one.
+                        // Neither is an empty region.
+                        if (BANDS_INTERSECT(Win2[0], Win1[0]))
                         {
-                           if (BAND_EMPTY(Win2[0]))
-                              Bands [B++] = Win2[0];
+                           OR_BANDS(Bands[0], Win2[0], Win1[0])
+                           if (BANDS_INTERSECT(Win2[0], Win1[1]))
+                              OR_BANDS(Bands[1], Win2[0], Win1[1])
                            else
-                           {
-                              AND_BANDS(Bands[0], Win1[0], Win2[0]);
-                              B = 1;
-                           }
+                              Bands[1] = Win1[1];
+                           B = 1;
+                           if (BANDS_INTERSECT(Bands[0], Bands[1]))
+                              OR_BANDS(Bands[0], Bands[0], Bands[1])
+                           else
+                              B = 2;
+                        }
+                        else if (BANDS_INTERSECT(Win2[0], Win1[1]))
+                        {
+                           Bands[B++] = Win1[0];
+                           OR_BANDS(Bands[B], Win2[0], Win1[1]);
+                           B++;
                         }
                         else
                         {
-                           AND_BANDS(Bands[0], Win1[0], Win2[0]);
-                           AND_BANDS(Bands[1], Win1[0], Win2[1]);
-                           B = 2;
+                           Bands[0] = Win1[0];
+                           Bands[1] = Win2[0];
+                           Bands[2] = Win1[1];
+                           B = 3;
                         }
                      }
+                  }
+                  else
+                  {
+                     // Both windows have two bands
+                     OR_BANDS(Bands[0], Win1[0], Win2[0]);
+                     OR_BANDS(Bands[1], Win1[1], Win2[1]);
+                     B = 1;
+                     if (BANDS_INTERSECT(Bands[0], Bands[1]))
+                        OR_BANDS(Bands[0], Bands[0], Bands[1])
+                     else
+                        B = 2;
+                  }
+                  break;
+               case CLIP_AND:
+                  if (Window1Enabled == 1)
+                  {
+                     // Window 1 has one band
+                     if (BAND_EMPTY(Win1[0]))
+                        Bands [B++] = Win1[0];
                      else if (Window2Enabled == 1)
                      {
                         if (BAND_EMPTY(Win2[0]))
-                           Bands[B++] = Win2[0];
+                           Bands [B++] = Win2[0];
                         else
                         {
-                           // Window 1 has two bands.
                            AND_BANDS(Bands[0], Win1[0], Win2[0]);
-                           AND_BANDS(Bands[1], Win1[1], Win2[0]);
-                           B = 2;
+                           B = 1;
                         }
                      }
                      else
                      {
-                        // Both windows have two bands.
                         AND_BANDS(Bands[0], Win1[0], Win2[0]);
-                        AND_BANDS(Bands[1], Win1[1], Win2[1]);
+                        AND_BANDS(Bands[1], Win1[0], Win2[1]);
                         B = 2;
-                        if (BANDS_INTERSECT(Win1[0], Win2[1]))
-                        {
-                           AND_BANDS(Bands[2], Win1[0], Win2[1]);
-                           B = 3;
-                        }
-                        else if (BANDS_INTERSECT(Win1[1], Win2[0]))
-                        {
-                           AND_BANDS(Bands[2], Win1[1], Win2[0]);
-                           B = 3;
-                        }
                      }
-                     break;
-                  case CLIP_XNOR:
-                     invert = !invert;
+                  }
+                  else if (Window2Enabled == 1)
+                  {
+                     if (BAND_EMPTY(Win2[0]))
+                        Bands[B++] = Win2[0];
+                     else
+                     {
+                        // Window 1 has two bands.
+                        AND_BANDS(Bands[0], Win1[0], Win2[0]);
+                        AND_BANDS(Bands[1], Win1[1], Win2[0]);
+                        B = 2;
+                     }
+                  }
+                  else
+                  {
+                     // Both windows have two bands.
+                     AND_BANDS(Bands[0], Win1[0], Win2[0]);
+                     AND_BANDS(Bands[1], Win1[1], Win2[1]);
+                     B = 2;
+                     if (BANDS_INTERSECT(Win1[0], Win2[1]))
+                     {
+                        AND_BANDS(Bands[2], Win1[0], Win2[1]);
+                        B = 3;
+                     }
+                     else if (BANDS_INTERSECT(Win1[1], Win2[0]))
+                     {
+                        AND_BANDS(Bands[2], Win1[1], Win2[0]);
+                        B = 3;
+                     }
+                  }
+                  break;
+               case CLIP_XNOR:
+                  invert = !invert;
                   // Fall...
+               case CLIP_XOR:
+                  if (Window1Enabled == 1 && BAND_EMPTY(Win1[0]))
+                  {
+                     B = Window2Enabled;
+                     // memmove converted: Different stack allocations [Neb]
+                     memcpy(Bands, Win2, sizeof(Win2[0]) * Window2Enabled);
+                  }
+                  else if (Window2Enabled == 1 && BAND_EMPTY(Win2[0]))
+                  {
+                     B = Window1Enabled;
+                     // memmove converted: Different stack allocations [Neb]
+                     memcpy(Bands, Win1, sizeof(Win1[0]) * Window1Enabled);
+                  }
+                  else
+                  {
+                     uint32_t p = 0;
+                     uint32_t points [10];
+                     uint32_t i;
 
-                  case CLIP_XOR:
-                     if (Window1Enabled == 1 && BAND_EMPTY(Win1[0]))
+                     invert = !invert;
+                     // Build an array of points (window edges)
+                     points [p++] = 0;
+                     for (i = 0; i < Window1Enabled; i++)
                      {
-                        B = Window2Enabled;
-                        // memmove converted: Different stack allocations [Neb]
-                        memcpy(Bands, Win2,
-                               sizeof(Win2[0]) * Window2Enabled);
+                        points [p++] = Win1[i].Left;
+                        points [p++] = Win1[i].Right;
                      }
-                     else if (Window2Enabled == 1 && BAND_EMPTY(Win2[0]))
+                     for (i = 0; i < Window2Enabled; i++)
                      {
-                        B = Window1Enabled;
-                        // memmove converted: Different stack allocations [Neb]
-                        memcpy(Bands, Win1,
-                               sizeof(Win1[0]) * Window1Enabled);
+                        points [p++] = Win2[i].Left;
+                        points [p++] = Win2[i].Right;
+                     }
+                     points [p++] = 256;
+                     // Sort them
+                     qsort((void*) points, p, sizeof(points [0]), IntCompare);
+                     for (i = 0; i < p; i += 2)
+                     {
+                        if (points [i] == points [i + 1])
+                           continue;
+                        Bands [B].Left = points [i];
+                        while (i + 2 < p && points [i + 1] == points [i + 2])
+                           i += 2;
+                        Bands [B++].Right = points [i + 1];
+                     }
+                  }
+                  break;
+               }
+               if (invert)
+               {
+                  int32_t b;
+                  int32_t j = 0;
+                  int32_t empty_band_count = 0;
+
+                  // First remove all empty bands from the list.
+                  for (b = 0; b < B; b++)
+                  {
+                     if (!BAND_EMPTY(Bands[b]))
+                     {
+                        if (b != j)
+                           Bands[j] = Bands[b];
+                        j++;
                      }
                      else
+                        empty_band_count++;
+                  }
+
+                  if (j > 0)
+                  {
+                     if (j == 1)
                      {
-                        uint32_t p = 0;
-                        uint32_t points [10];
-                        uint32_t i;
+                        j = 0;
+                        // Easy case to deal with, so special case it.
 
-                        invert = !invert;
-                        // Build an array of points (window edges)
-                        points [p++] = 0;
-                        for (i = 0; i < Window1Enabled; i++)
+                        if (Bands[0].Left > 0)
                         {
-                           points [p++] = Win1[i].Left;
-                           points [p++] = Win1[i].Right;
+                           pClip->Left[j][w] = 0;
+                           pClip->Right[j++][w] = Bands[0].Left + 1;
                         }
-                        for (i = 0; i < Window2Enabled; i++)
+                        if (Bands[0].Right < 256)
                         {
-                           points [p++] = Win2[i].Left;
-                           points [p++] = Win2[i].Right;
+                           pClip->Left[j][w] = Bands[0].Right;
+                           pClip->Right[j++][w] = 256;
                         }
-                        points [p++] = 256;
-                        // Sort them
-                        qsort((void*) points, p, sizeof(points [0]),
-                              IntCompare);
-                        for (i = 0; i < p; i += 2)
+                        if (j == 0)
                         {
-                           if (points [i] == points [i + 1])
-                              continue;
-                           Bands [B].Left = points [i];
-                           while (i + 2 < p &&
-                                  points [i + 1] == points [i + 2])
-                              i += 2;
-                           Bands [B++].Right = points [i + 1];
+                           pClip->Left[j][w] = 1;
+                           pClip->Right[j++][w] = 0;
                         }
                      }
-                     break;
-                  }
-                  if (invert)
-                  {
-                     int b;
-                     int j = 0;
-                     int empty_band_count = 0;
-
-                     // First remove all empty bands from the list.
-                     for (b = 0; b < B; b++)
+                     else
                      {
-                        if (!BAND_EMPTY(Bands[b]))
-                        {
-                           if (b != j)
-                              Bands[j] = Bands[b];
-                           j++;
-                        }
-                        else
-                           empty_band_count++;
-                     }
+                        // Now sort the bands into order
+                        B = j;
+                        qsort((void*) Bands, B, sizeof(Bands [0]), BandCompare);
 
-                     if (j > 0)
-                     {
-                        if (j == 1)
+                        // Now invert the area the bands cover
+                        j = 0;
+                        for (b = 0; b < B; b++)
                         {
-                           j = 0;
-                           // Easy case to deal with, so special case it.
-
-                           if (Bands[0].Left > 0)
+                           if (b == 0 && Bands[b].Left > 0)
                            {
                               pClip->Left[j][w] = 0;
-                              pClip->Right[j++][w] = Bands[0].Left + 1;
+                              pClip->Right[j++][w] = Bands[b].Left + 1;
                            }
-                           if (Bands[0].Right < 256)
+                           else if (b == B - 1 && Bands[b].Right < 256)
                            {
-                              pClip->Left[j][w] = Bands[0].Right;
+                              pClip->Left[j][w] = Bands[b].Right;
                               pClip->Right[j++][w] = 256;
                            }
-                           if (j == 0)
-                           {
-                              pClip->Left[j][w] = 1;
-                              pClip->Right[j++][w] = 0;
-                           }
-                        }
-                        else
-                        {
-                           // Now sort the bands into order
-                           B = j;
-                           qsort((void*) Bands, B,
-                                 sizeof(Bands [0]), BandCompare);
-
-                           // Now invert the area the bands cover
-                           j = 0;
-                           for (b = 0; b < B; b++)
+                           if (b < B - 1)
                            {
-                              if (b == 0 && Bands[b].Left > 0)
-                              {
-                                 pClip->Left[j][w] = 0;
-                                 pClip->Right[j++][w] = Bands[b].Left + 1;
-                              }
-                              else if (b == B - 1 && Bands[b].Right < 256)
-                              {
-                                 pClip->Left[j][w] = Bands[b].Right;
-                                 pClip->Right[j++][w] = 256;
-                              }
-                              if (b < B - 1)
-                              {
-                                 pClip->Left[j][w] = Bands[b].Right;
-                                 pClip->Right[j++][w] = Bands[b + 1].Left + 1;
-                              }
+                              pClip->Left[j][w] = Bands[b].Right;
+                              pClip->Right[j++][w] = Bands[b + 1].Left + 1;
                            }
                         }
                      }
-                     else
-                     {
-                        // Inverting a window that consisted of only
-                        // empty bands is the whole width of the screen.
-                        // Needed for Mario Kart's rear-view mirror display.
-                        if (empty_band_count)
-                        {
-                           pClip->Left[j][w] = 0;
-                           pClip->Right[j][w] = 256;
-                           j++;
-                        }
-                     }
-                     pClip->Count[w] = j;
                   }
                   else
                   {
-                     int j;
-                     for (j = 0; j < B; j++)
+                     // Inverting a window that consisted of only
+                     // empty bands is the whole width of the screen.
+                     // Needed for Mario Kart's rear-view mirror display.
+                     if (empty_band_count)
                      {
-                        pClip->Left[j][w] = Bands[j].Left;
-                        pClip->Right[j][w] = Bands[j].Right;
+                        pClip->Left[j][w] = 0;
+                        pClip->Right[j][w] = 256;
+                        j++;
                      }
-                     pClip->Count [w] = B;
                   }
+                  pClip->Count[w] = j;
                }
                else
                {
-                  // Only one window enabled so no need to perform
-                  // complex overlap logic...
+                  int32_t j;
+                  for (j = 0; j < B; j++)
+                  {
+                     pClip->Left[j][w] = Bands[j].Left;
+                     pClip->Right[j][w] = Bands[j].Right;
+                  }
+                  pClip->Count [w] = B;
+               }
+            }
+            else
+            {
+               // Only one window enabled so no need to perform
+               // complex overlap logic...
 
-                  if (Window1Enabled)
+               if (Window1Enabled)
+               {
+                  if (invert)
                   {
-                     if (invert)
-                     {
-                        int j = 0;
+                     int32_t j = 0;
 
-                        if (Window1Enabled == 1)
+                     if (Window1Enabled == 1)
+                     {
+                        if (Win1[0].Left <= Win1[0].Right)
                         {
-                           if (Win1[0].Left <= Win1[0].Right)
+                           if (Win1[0].Left > 0)
                            {
-                              if (Win1[0].Left > 0)
-                              {
-                                 pClip->Left[j][w] = 0;
-                                 pClip->Right[j++][w] = Win1[0].Left;
-                              }
-                              if (Win1[0].Right < 256)
-                              {
-                                 pClip->Left[j][w] = Win1[0].Right;
-                                 pClip->Right[j++][w] = 256;
-                              }
-                              if (j == 0)
-                              {
-                                 pClip->Left[j][w] = 1;
-                                 pClip->Right[j++][w] = 0;
-                              }
+                              pClip->Left[j][w] = 0;
+                              pClip->Right[j++][w] = Win1[0].Left;
                            }
-                           else
+                           if (Win1[0].Right < 256)
                            {
-                              pClip->Left[j][w] = 0;
+                              pClip->Left[j][w] = Win1[0].Right;
                               pClip->Right[j++][w] = 256;
                            }
+                           if (j == 0)
+                           {
+                              pClip->Left[j][w] = 1;
+                              pClip->Right[j++][w] = 0;
+                           }
                         }
                         else
                         {
-                           pClip->Left [j][w] = Win1[0].Right;
-                           pClip->Right[j++][w] = Win1[1].Left;
+                           pClip->Left[j][w] = 0;
+                           pClip->Right[j++][w] = 256;
                         }
-                        pClip->Count [w] = j;
                      }
                      else
                      {
-                        uint32_t j;
-                        for (j = 0; j < Window1Enabled; j++)
-                        {
-                           pClip->Left [j][w] = Win1[j].Left;
-                           pClip->Right [j][w] = Win1[j].Right;
-                        }
-                        pClip->Count [w] = Window1Enabled;
+                        pClip->Left [j][w] = Win1[0].Right;
+                        pClip->Right[j++][w] = Win1[1].Left;
                      }
+                     pClip->Count [w] = j;
                   }
-                  else if (Window2Enabled)
+                  else
                   {
-                     if (invert)
+                     uint32_t j;
+                     for (j = 0; j < Window1Enabled; j++)
                      {
-                        int j = 0;
-                        if (Window2Enabled == 1)
+                        pClip->Left [j][w] = Win1[j].Left;
+                        pClip->Right [j][w] = Win1[j].Right;
+                     }
+                     pClip->Count [w] = Window1Enabled;
+                  }
+               }
+               else if (Window2Enabled)
+               {
+                  if (invert)
+                  {
+                     int32_t j = 0;
+                     if (Window2Enabled == 1)
+                     {
+                        if (Win2[0].Left <= Win2[0].Right)
                         {
-                           if (Win2[0].Left <= Win2[0].Right)
+                           if (Win2[0].Left > 0)
                            {
-                              if (Win2[0].Left > 0)
-                              {
-                                 pClip->Left[j][w] = 0;
-                                 pClip->Right[j++][w] = Win2[0].Left;
-                              }
-                              if (Win2[0].Right < 256)
-                              {
-                                 pClip->Left[j][w] = Win2[0].Right;
-                                 pClip->Right[j++][w] = 256;
-                              }
-                              if (j == 0)
-                              {
-                                 pClip->Left[j][w] = 1;
-                                 pClip->Right[j++][w] = 0;
-                              }
+                              pClip->Left[j][w] = 0;
+                              pClip->Right[j++][w] = Win2[0].Left;
                            }
-                           else
+                           if (Win2[0].Right < 256)
                            {
-                              pClip->Left[j][w] = 0;
+                              pClip->Left[j][w] = Win2[0].Right;
                               pClip->Right[j++][w] = 256;
                            }
+                           if (j == 0)
+                           {
+                              pClip->Left[j][w] = 1;
+                              pClip->Right[j++][w] = 0;
+                           }
                         }
                         else
                         {
-                           pClip->Left [j][w] = Win2[0].Right;
-                           pClip->Right[j++][w] = Win2[1].Left + 1;
+                           pClip->Left[j][w] = 0;
+                           pClip->Right[j++][w] = 256;
                         }
-                        pClip->Count [w] = j;
                      }
                      else
                      {
-                        uint32_t j;
-                        for (j = 0; j < Window2Enabled; j++)
-                        {
-                           pClip->Left [j][w] = Win2[j].Left;
-                           pClip->Right [j][w] = Win2[j].Right;
-                        }
-                        pClip->Count [w] = Window2Enabled;
+                        pClip->Left [j][w] = Win2[0].Right;
+                        pClip->Right[j++][w] = Win2[1].Left + 1;
+                     }
+                     pClip->Count [w] = j;
+                  }
+                  else
+                  {
+                     uint32_t j;
+                     for (j = 0; j < Window2Enabled; j++)
+                     {
+                        pClip->Left [j][w] = Win2[j].Left;
+                        pClip->Right [j][w] = Win2[j].Right;
                      }
+                     pClip->Count [w] = Window2Enabled;
                   }
                }
+            }
 
-               if (w != 5 && pClip->Count [5])
+            if (w != 5 && pClip->Count [5])
+            {
+               // Colour window enabled. Set the
+               // clip windows for all remaining backgrounds to be
+               // the same as the colour window.
+               if (pClip->Count [w] == 0)
                {
-                  // Colour window enabled. Set the
-                  // clip windows for all remaining backgrounds to be
-                  // the same as the colour window.
-                  if (pClip->Count [w] == 0)
+                  uint32_t i;
+                  pClip->Count [w] = pClip->Count [5];
+                  for (i = 0; i < pClip->Count [w]; i++)
                   {
-                     uint32_t i;
-                     pClip->Count [w] = pClip->Count [5];
-                     for (i = 0; i < pClip->Count [w]; i++)
-                     {
-                        pClip->Left [i][w] = pClip->Left [i][5];
-                        pClip->Right [i][w] = pClip->Right [i][5];
-                     }
+                     pClip->Left [i][w] = pClip->Left [i][5];
+                     pClip->Right [i][w] = pClip->Right [i][5];
                   }
-                  else
+               }
+               else
+               {
+                  // Intersect the colour window with the bg's
+                  // own clip window.
+                  uint32_t i;
+                  for (i = 0; i < pClip->Count [w]; i++)
                   {
-                     // Intersect the colour window with the bg's
-                     // own clip window.
-                     uint32_t i;
-                     for (i = 0; i < pClip->Count [w]; i++)
+                     uint32_t j;
+                     for (j = 0; j < pClip->Count [5]; j++)
                      {
-                        uint32_t j;
-                        for (j = 0; j < pClip->Count [5]; j++)
+                        if ((pClip->Left[i][w] >= pClip->Left[j][5]
+                              && pClip->Left[i][w] < pClip->Right[j][5])
+                              || (pClip->Left[j][5] >= pClip->Left[i][w]
+                                  && pClip->Left[j][5] < pClip->Right[i][w]))
                         {
-                           if ((pClip->Left[i][w] >= pClip->Left[j][5]
-                                 && pClip->Left[i][w] < pClip->Right[j][5])
-                                 || (pClip->Left[j][5] >= pClip->Left[i][w]
-                                     && pClip->Left[j][5] < pClip->Right[i][w]))
-                           {
-                              // Found an intersection!
-                              pClip->Left[i][w] = MAX(pClip->Left[i][w], pClip->Left[j][5]);
-                              pClip->Right[i][w] = MIN(pClip->Right[i][w], pClip->Right[j][5]);
-                              goto Clip_ok;
-                           }
+                           // Found an intersection!
+                           pClip->Left[i][w] = MAX(pClip->Left[i][w], pClip->Left[j][5]);
+                           pClip->Right[i][w] = MIN(pClip->Right[i][w], pClip->Right[j][5]);
+                           goto Clip_ok;
                         }
-                        // no intersection, nullify it
-                        pClip->Left[i][w] = 1;
-                        pClip->Right[i][w] = 0;
-Clip_ok:;
                      }
+                     // no intersection, nullify it
+                     pClip->Left[i][w] = 1;
+                     pClip->Right[i][w] = 0;
+Clip_ok:;
                   }
                }
-            } // if (w == 5 | ...
-         } // if (!Settings.DisableGraphicWindows)
-      } // for (int w...
-   } // for (int c...
+            }
+         } // if (w == 5 || pClip->Count [5] ...
+      } // for (w...
+   } // for (c...
 }