rename local vars 'pixel' to 'pixelvalue'

Reference issue: https://github.com/libsdl-org/SDL/issues/12749.

src/render/software/SDL_triangle.c

@@ -945,9 +945,9 @@ static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
             ASSEMBLE_RGB(dst, dstbpp, dst_fmt, dstR, dstG, dstB);
         } else {
             // SDL_PIXELFORMAT_ARGB2101010
-            Uint32 pixel;
-            ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
-            *(Uint32 *)dst = pixel;
+            Uint32 pixelvalue;
+            ARGB2101010_FROM_RGBA(pixelvalue, dstR, dstG, dstB, dstA);
+            *(Uint32 *)dst = pixelvalue;
         }
     }
     TRIANGLE_END_LOOP

src/video/SDL_blit_0.c

@@ -617,7 +617,7 @@ static void BlitBtoNAlpha(SDL_BlitInfo *info)
     const SDL_PixelFormatDetails *dstfmt = info->dst_fmt;
     int srcbpp, dstbpp;
     int c;
-    Uint32 pixel, mask, align;
+    Uint32 pixelvalue, mask, align;
     unsigned sR, sG, sB;
     unsigned dR, dG, dB, dA;
     const unsigned A = info->a;
@@ -646,7 +646,7 @@ static void BlitBtoNAlpha(SDL_BlitInfo *info)
                     sR = srcpal[bit].r;
                     sG = srcpal[bit].g;
                     sB = srcpal[bit].b;
-                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
                     ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
                     ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
                 }
@@ -668,7 +668,7 @@ static void BlitBtoNAlpha(SDL_BlitInfo *info)
                     sR = srcpal[bit].r;
                     sG = srcpal[bit].g;
                     sB = srcpal[bit].b;
-                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
                     ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
                     ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
                 }
@@ -694,7 +694,7 @@ static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
     const SDL_Color *srcpal = info->src_pal->colors;
     int srcbpp, dstbpp;
     int c;
-    Uint32 pixel, mask, align;
+    Uint32 pixelvalue, mask, align;
     unsigned sR, sG, sB;
     unsigned dR, dG, dB, dA;
     const unsigned A = info->a;
@@ -724,7 +724,7 @@ static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
                     sR = srcpal[bit].r;
                     sG = srcpal[bit].g;
                     sB = srcpal[bit].b;
-                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
                     ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
                     ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
                 }
@@ -746,7 +746,7 @@ static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
                     sR = srcpal[bit].r;
                     sG = srcpal[bit].g;
                     sB = srcpal[bit].b;
-                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+                    DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
                     ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
                     ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
                 }

src/video/SDL_blit_1.c

@@ -434,7 +434,7 @@ static void Blit1toNAlpha(SDL_BlitInfo *info)
     const SDL_PixelFormatDetails *dstfmt = info->dst_fmt;
     const SDL_Color *srcpal = info->src_pal->colors;
     int dstbpp;
-    Uint32 pixel;
+    Uint32 pixelvalue;
     unsigned sR, sG, sB, sA;
     unsigned dR, dG, dB, dA;
     const unsigned A = info->a;
@@ -450,7 +450,7 @@ static void Blit1toNAlpha(SDL_BlitInfo *info)
             sG = srcpal[*src].g;
             sB = srcpal[*src].b;
             sA = (srcpal[*src].a * A) / 255;
-            DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+            DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
             ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
             ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
             src++;
@@ -475,7 +475,7 @@ static void Blit1toNAlphaKey(SDL_BlitInfo *info)
     const SDL_Color *srcpal = info->src_pal->colors;
     Uint32 ckey = info->colorkey;
     int dstbpp;
-    Uint32 pixel;
+    Uint32 pixelvalue;
     unsigned sR, sG, sB, sA;
     unsigned dR, dG, dB, dA;
     const unsigned A = info->a;
@@ -492,7 +492,7 @@ static void Blit1toNAlphaKey(SDL_BlitInfo *info)
                 sG = srcpal[*src].g;
                 sB = srcpal[*src].b;
                 sA = (srcpal[*src].a * A) / 255;
-                DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
+                DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixelvalue, dR, dG, dB, dA);
                 ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
                 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
             }

src/video/SDL_blit_slow.c

@@ -296,25 +296,25 @@ void SDL_Blit_Slow(SDL_BlitInfo *info)
                 break;
             case SlowBlitPixelAccess_10Bit:
             {
-                Uint32 pixel;
+                Uint32 pixelvalue;
                 switch (dst_fmt->format) {
                 case SDL_PIXELFORMAT_XRGB2101010:
                     dstA = 0xFF;
                     SDL_FALLTHROUGH;
                 case SDL_PIXELFORMAT_ARGB2101010:
-                    ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
+                    ARGB2101010_FROM_RGBA(pixelvalue, dstR, dstG, dstB, dstA);
                     break;
                 case SDL_PIXELFORMAT_XBGR2101010:
                     dstA = 0xFF;
                     SDL_FALLTHROUGH;
                 case SDL_PIXELFORMAT_ABGR2101010:
-                    ABGR2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
+                    ABGR2101010_FROM_RGBA(pixelvalue, dstR, dstG, dstB, dstA);
                     break;
                 default:
-                    pixel = 0;
+                    pixelvalue = 0;
                     break;
                 }
-                *(Uint32 *)dst = pixel;
+                *(Uint32 *)dst = pixelvalue;
                 break;
             }
             case SlowBlitPixelAccess_Large:
@@ -424,49 +424,49 @@ static Uint16 float_to_half(float a)
 static void ReadFloatPixel(Uint8 *pixels, SlowBlitPixelAccess access, const SDL_PixelFormatDetails *fmt, const SDL_Palette *pal, SDL_Colorspace colorspace, float SDR_white_point,
                            float *outR, float *outG, float *outB, float *outA)
 {
-    Uint32 pixel;
+    Uint32 pixelvalue;
     Uint32 R, G, B, A;
     float fR = 0.0f, fG = 0.0f, fB = 0.0f, fA = 0.0f;
     float v[4];
 
     switch (access) {
     case SlowBlitPixelAccess_Index8:
-        pixel = *pixels;
-        fR = (float)pal->colors[pixel].r / 255.0f;
-        fG = (float)pal->colors[pixel].g / 255.0f;
-        fB = (float)pal->colors[pixel].b / 255.0f;
-        fA = (float)pal->colors[pixel].a / 255.0f;
+        pixelvalue = *pixels;
+        fR = (float)pal->colors[pixelvalue].r / 255.0f;
+        fG = (float)pal->colors[pixelvalue].g / 255.0f;
+        fB = (float)pal->colors[pixelvalue].b / 255.0f;
+        fA = (float)pal->colors[pixelvalue].a / 255.0f;
         break;
     case SlowBlitPixelAccess_RGB:
-        DISEMBLE_RGB(pixels, fmt->bytes_per_pixel, fmt, pixel, R, G, B);
+        DISEMBLE_RGB(pixels, fmt->bytes_per_pixel, fmt, pixelvalue, R, G, B);
         fR = (float)R / 255.0f;
         fG = (float)G / 255.0f;
         fB = (float)B / 255.0f;
         fA = 1.0f;
         break;
     case SlowBlitPixelAccess_RGBA:
-        DISEMBLE_RGBA(pixels, fmt->bytes_per_pixel, fmt, pixel, R, G, B, A);
+        DISEMBLE_RGBA(pixels, fmt->bytes_per_pixel, fmt, pixelvalue, R, G, B, A);
         fR = (float)R / 255.0f;
         fG = (float)G / 255.0f;
         fB = (float)B / 255.0f;
         fA = (float)A / 255.0f;
         break;
     case SlowBlitPixelAccess_10Bit:
-        pixel = *((Uint32 *)pixels);
+        pixelvalue = *((Uint32 *)pixels);
         switch (fmt->format) {
         case SDL_PIXELFORMAT_XRGB2101010:
-            RGBAFLOAT_FROM_ARGB2101010(pixel, fR, fG, fB, fA);
+            RGBAFLOAT_FROM_ARGB2101010(pixelvalue, fR, fG, fB, fA);
             fA = 1.0f;
             break;
         case SDL_PIXELFORMAT_XBGR2101010:
-            RGBAFLOAT_FROM_ABGR2101010(pixel, fR, fG, fB, fA);
+            RGBAFLOAT_FROM_ABGR2101010(pixelvalue, fR, fG, fB, fA);
             fA = 1.0f;
             break;
         case SDL_PIXELFORMAT_ARGB2101010:
-            RGBAFLOAT_FROM_ARGB2101010(pixel, fR, fG, fB, fA);
+            RGBAFLOAT_FROM_ARGB2101010(pixelvalue, fR, fG, fB, fA);
             break;
         case SDL_PIXELFORMAT_ABGR2101010:
-            RGBAFLOAT_FROM_ABGR2101010(pixel, fR, fG, fB, fA);
+            RGBAFLOAT_FROM_ABGR2101010(pixelvalue, fR, fG, fB, fA);
             break;
         default:
             fR = fG = fB = fA = 0.0f;
@@ -587,7 +587,7 @@ static void WriteFloatPixel(Uint8 *pixels, SlowBlitPixelAccess access, const SDL
                             float fR, float fG, float fB, float fA)
 {
     Uint32 R, G, B, A;
-    Uint32 pixel;
+    Uint32 pixelvalue;
     float v[4];
 
     // We converted to nits so src and dst are guaranteed to be linear and in the same units
@@ -637,19 +637,19 @@ static void WriteFloatPixel(Uint8 *pixels, SlowBlitPixelAccess access, const SDL
             fA = 1.0f;
             SDL_FALLTHROUGH;
         case SDL_PIXELFORMAT_ARGB2101010:
-            ARGB2101010_FROM_RGBAFLOAT(pixel, fR, fG, fB, fA);
+            ARGB2101010_FROM_RGBAFLOAT(pixelvalue, fR, fG, fB, fA);
             break;
         case SDL_PIXELFORMAT_XBGR2101010:
             fA = 1.0f;
             SDL_FALLTHROUGH;
         case SDL_PIXELFORMAT_ABGR2101010:
-            ABGR2101010_FROM_RGBAFLOAT(pixel, fR, fG, fB, fA);
+            ABGR2101010_FROM_RGBAFLOAT(pixelvalue, fR, fG, fB, fA);
             break;
         default:
-            pixel = 0;
+            pixelvalue = 0;
             break;
         }
-        *(Uint32 *)pixels = pixel;
+        *(Uint32 *)pixels = pixelvalue;
         break;
     }
     case SlowBlitPixelAccess_Large:

src/video/SDL_bmp.c

@@ -92,13 +92,13 @@ static bool readRlePixels(SDL_Surface *surface, SDL_IOStream *src, int isRle8)
         | with two colour indexes to alternate between for the run
         */
         if (ch) {
-            Uint8 pixel;
-            if (!SDL_ReadU8(src, &pixel)) {
+            Uint8 pixelvalue;
+            if (!SDL_ReadU8(src, &pixelvalue)) {
                 return false;
             }
             ch /= pixels_per_byte;
             do {
-                COPY_PIXEL(pixel);
+                COPY_PIXEL(pixelvalue);
             } while (--ch);
         } else {
             /*
@@ -131,11 +131,11 @@ static bool readRlePixels(SDL_Surface *surface, SDL_IOStream *src, int isRle8)
                 ch /= pixels_per_byte;
                 needsPad = (ch & 1);
                 do {
-                    Uint8 pixel;
-                    if (!SDL_ReadU8(src, &pixel)) {
+                    Uint8 pixelvalue;
+                    if (!SDL_ReadU8(src, &pixelvalue)) {
                         return false;
                     }
-                    COPY_PIXEL(pixel);
+                    COPY_PIXEL(pixelvalue);
                 } while (--ch);
 
                 // pad at even boundary

src/video/SDL_pixels.c

@@ -1133,7 +1133,7 @@ Uint8 SDL_FindColor(const SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
     unsigned int distance;
     int rd, gd, bd, ad;
     int i;
-    Uint8 pixel = 0;
+    Uint8 pixelvalue = 0;
 
     smallest = ~0U;
     for (i = 0; i < pal->ncolors; ++i) {
@@ -1143,14 +1143,14 @@ Uint8 SDL_FindColor(const SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
         ad = pal->colors[i].a - a;
         distance = (rd * rd) + (gd * gd) + (bd * bd) + (ad * ad);
         if (distance < smallest) {
-            pixel = (Uint8)i;
+            pixelvalue = (Uint8)i;
             if (distance == 0) { // Perfect match!
                 break;
             }
             smallest = distance;
         }
     }
-    return pixel;
+    return pixelvalue;
 }
 
 Uint8 SDL_LookupRGBAColor(SDL_HashTable *palette_map, Uint32 pixelvalue, const SDL_Palette *pal)