Evas ETC2: Fix horrible warnings in etc2_encoder

So I guess always compiling with debug flags and no
optimizations isn't the best idea as some really bad warnings
can be hidden. Thanks raster for the notice.

1 files changed, 68 insertions, 80 deletions

diff --git a/src/static_libs/rg_etc/etc2_encoder.c b/src/static_libs/rg_etc/etc2_encoder.c
index 2928974df2..d4bc11c3d5 100644
--- a/src/static_libs/rg_etc/etc2_encoder.c
+++ b/src/static_libs/rg_etc/etc2_encoder.c
@@ -105,25 +105,10 @@ static const int kBlockWalk[16] = {
 // Write a BGRA value for output to Evas
 #define BGRA(r,g,b,a) ((a << 24) | (r << 16) | (g << 8) | b)
 
-#ifndef WORDS_BIGENDIAN
-/* x86 */
-#define A_VAL(p) (((uint8_t *)(p))[3])
-#define R_VAL(p) (((uint8_t *)(p))[2])
-#define G_VAL(p) (((uint8_t *)(p))[1])
-#define B_VAL(p) (((uint8_t *)(p))[0])
-#define R_IDX 2
-#define G_IDX 1
-#define B_IDX 0
-#else
-/* ppc */
-#define A_VAL(p) (((uint8_t *)(p))[0])
-#define R_VAL(p) (((uint8_t *)(p))[1])
-#define G_VAL(p) (((uint8_t *)(p))[2])
-#define B_VAL(p) (((uint8_t *)(p))[3])
-#define R_IDX 1
-#define G_IDX 2
-#define B_IDX 3
-#endif
+#define A_VAL(v) ((uint8_t) ((v & 0xFF000000) >> 24))
+#define R_VAL(v) ((uint8_t) ((v & 0x00FF0000) >> 16))
+#define G_VAL(v) ((uint8_t) ((v & 0x0000FF00) >> 8))
+#define B_VAL(v) ((uint8_t) ((v & 0x000000FF)))
 
 #ifndef DBG
 # ifdef DEBUG
@@ -158,7 +143,7 @@ _etc2_alpha_block_pack(uint8_t *etc2_alpha,
    // Compute alphas now
    for (int i = 0; i < 16; i++)
      {
-        const int realA = A_VAL(bgra + kBlockWalk[i]);
+        const int realA = A_VAL(bgra[kBlockWalk[i]]);
         int minErr = INT_MAX, idx = 0;
 
         // Brute force -- find modifier index
@@ -206,12 +191,12 @@ _etc2_alpha_encode(uint8_t *etc2_alpha, const uint32_t *bgra,
    int base_codeword;
    int multiplier, bestMult = 0;
    int modifierIdx, bestIdx = 0, bestBase = 128;
-   int err, base_range, base_step = 1, max_error = 0;
+   int err, base_range = 40, base_step = 4, max_error = 0;
 
    // Try to select the best alpha value (avg)
    for (int i = 0; i < 16; i++)
      {
-        alphas[i] = A_VAL(bgra + kBlockWalk[i]);
+        alphas[i] = A_VAL(bgra[kBlockWalk[i]]);
         avg += alphas[i];
      }
    avg /= 16;
@@ -294,12 +279,12 @@ _etc2_t_mode_header_pack(uint8_t *etc2,
                          uint32_t color1, uint32_t color2, int distance)
 {
    // 4 bit colors
-   int r1_4 = R_VAL(&color1) >> 4;
-   int g1_4 = G_VAL(&color1) >> 4;
-   int b1_4 = B_VAL(&color1) >> 4;
-   int r2_4 = R_VAL(&color2) >> 4;
-   int g2_4 = G_VAL(&color2) >> 4;
-   int b2_4 = B_VAL(&color2) >> 4;
+   int r1_4 = R_VAL(color1) >> 4;
+   int g1_4 = G_VAL(color1) >> 4;
+   int b1_4 = B_VAL(color1) >> 4;
+   int r2_4 = R_VAL(color2) >> 4;
+   int g2_4 = G_VAL(color2) >> 4;
+   int b2_4 = B_VAL(color2) >> 4;
    int distanceIdx, R, dR;
 
    for (distanceIdx = 0; distanceIdx < 8; distanceIdx++)
@@ -378,12 +363,12 @@ _etc2_h_mode_header_pack(uint8_t *etc2, Eina_Bool *swap_colors,
    *swap_colors = (c1 != color1);
 
    // 4 bit colors
-   r1_4 = R_VAL(&c1) >> 4;
-   g1_4 = G_VAL(&c1) >> 4;
-   b1_4 = B_VAL(&c1) >> 4;
-   r2_4 = R_VAL(&c2) >> 4;
-   g2_4 = G_VAL(&c2) >> 4;
-   b2_4 = B_VAL(&c2) >> 4;
+   r1_4 = R_VAL(c1) >> 4;
+   g1_4 = G_VAL(c1) >> 4;
+   b1_4 = B_VAL(c1) >> 4;
+   r2_4 = R_VAL(c2) >> 4;
+   g2_4 = G_VAL(c2) >> 4;
+   b2_4 = B_VAL(c2) >> 4;
 
    // R1 + G1a. R + [dR] must be inside [0..31]. Scanning all values. Not smart.
    R  = r1_4;
@@ -431,18 +416,18 @@ _etc2_h_mode_header_pack(uint8_t *etc2, Eina_Bool *swap_colors,
 static inline int
 _rgb_distance_percept(uint32_t color1, uint32_t color2)
 {
-   int R = R_VAL(&color1) - R_VAL(&color2);
-   int G = G_VAL(&color1) - G_VAL(&color2);
-   int B = B_VAL(&color1) - B_VAL(&color2);
+   int R = R_VAL(color1) - R_VAL(color2);
+   int G = G_VAL(color1) - G_VAL(color2);
+   int B = B_VAL(color1) - B_VAL(color2);
    return (R * R * R_WEIGHT) + (G * G * G_WEIGHT) + (B * B * B_WEIGHT);
 }
 
 static inline int
 _rgb_distance_euclid(uint32_t color1, uint32_t color2)
 {
-   int R = R_VAL(&color1) - R_VAL(&color2);
-   int G = G_VAL(&color1) - G_VAL(&color2);
-   int B = B_VAL(&color1) - B_VAL(&color2);
+   int R = R_VAL(color1) - R_VAL(color2);
+   int G = G_VAL(color1) - G_VAL(color2);
+   int B = B_VAL(color1) - B_VAL(color2);
    return (R * R) + (G * G) + (B * B);
 }
 
@@ -452,7 +437,10 @@ _etc2_th_mode_block_pack(uint8_t *etc2, Eina_Bool h_mode,
                          const uint32_t *bgra, Eina_Bool write,
                          Eina_Bool *swap_colors)
 {
-   uint8_t paint_colors[4][4];
+   union {
+      uint8_t c[4];
+      uint32_t v;
+   } paint_colors[4];
    int errAcc = 0;
 
    if (write)
@@ -481,17 +469,17 @@ _etc2_th_mode_block_pack(uint8_t *etc2, Eina_Bool h_mode,
      {
         if (!h_mode)
           {
-             paint_colors[0][k] = ((uint8_t *) &color1)[k];
-             paint_colors[1][k] = CLAMP(((uint8_t *) &color2)[k] + distance);
-             paint_colors[2][k] = ((uint8_t *) &color2)[k];
-             paint_colors[3][k] = CLAMP(((uint8_t *) &color2)[k] - distance);
+             paint_colors[0].c[k] = ((uint8_t *) &color1)[k];
+             paint_colors[1].c[k] = CLAMP(((uint8_t *) &color2)[k] + distance);
+             paint_colors[2].c[k] = ((uint8_t *) &color2)[k];
+             paint_colors[3].c[k] = CLAMP(((uint8_t *) &color2)[k] - distance);
           }
         else
           {
-             paint_colors[0][k] = CLAMP(((uint8_t *) &color1)[k] + distance);
-             paint_colors[1][k] = CLAMP(((uint8_t *) &color1)[k] - distance);
-             paint_colors[2][k] = CLAMP(((uint8_t *) &color2)[k] + distance);
-             paint_colors[3][k] = CLAMP(((uint8_t *) &color2)[k] - distance);
+             paint_colors[0].c[k] = CLAMP(((uint8_t *) &color1)[k] + distance);
+             paint_colors[1].c[k] = CLAMP(((uint8_t *) &color1)[k] - distance);
+             paint_colors[2].c[k] = CLAMP(((uint8_t *) &color2)[k] + distance);
+             paint_colors[3].c[k] = CLAMP(((uint8_t *) &color2)[k] - distance);
           }
      }
 
@@ -503,7 +491,7 @@ _etc2_th_mode_block_pack(uint8_t *etc2, Eina_Bool h_mode,
 
         for (int idx = 0; idx < 4; idx++)
           {
-             int dist = _rgb_distance_euclid(pixel, *((uint32_t *) paint_colors[idx]));
+             int dist = _rgb_distance_euclid(pixel, paint_colors[idx].v);
              if (dist < bestDist)
                {
                   bestDist = dist;
@@ -527,9 +515,9 @@ _etc2_th_mode_block_pack(uint8_t *etc2, Eina_Bool h_mode,
 static uint32_t
 _color_reduce_444(uint32_t color)
 {
-   int R = R_VAL(&color);
-   int G = G_VAL(&color);
-   int B = B_VAL(&color);
+   int R = R_VAL(color);
+   int G = G_VAL(color);
+   int B = B_VAL(color);
    int R1, R2, G1, G2, B1, B2;
 
    R1 = (R & 0xF0) | (R >> 4);
@@ -549,9 +537,9 @@ _color_reduce_444(uint32_t color)
 static uint32_t
 _color_reduce_676(uint32_t color)
 {
-   int R = R_VAL(&color);
-   int G = G_VAL(&color);
-   int B = B_VAL(&color);
+   int R = R_VAL(color);
+   int G = G_VAL(color);
+   int B = B_VAL(color);
    int R1, G1, B1;
 
    // FIXME: Do we have better candidates to try?
@@ -628,16 +616,16 @@ _block_main_colors_find(uint32_t *color1_out, uint32_t *color2_out,
         // k-means update step
         for (int k = 0; k < cluster1_cnt; k++)
           {
-             r1 += R_VAL(bgra + cluster1[k]);
-             g1 += G_VAL(bgra + cluster1[k]);
-             b1 += B_VAL(bgra + cluster1[k]);
+             r1 += R_VAL(bgra[cluster1[k]]);
+             g1 += G_VAL(bgra[cluster1[k]]);
+             b1 += B_VAL(bgra[cluster1[k]]);
           }
 
         for (int k = 0; k < cluster2_cnt; k++)
           {
-             r2 += R_VAL(bgra + cluster2[k]);
-             g2 += G_VAL(bgra + cluster2[k]);
-             b2 += B_VAL(bgra + cluster2[k]);
+             r2 += R_VAL(bgra[cluster2[k]]);
+             g2 += G_VAL(bgra[cluster2[k]]);
+             b2 += B_VAL(bgra[cluster2[k]]);
           }
 
         r1 /= cluster1_cnt;
@@ -859,15 +847,15 @@ _etc2_planar_mode_block_pack(uint8_t *etc2,
    unsigned int err = 0;
    uint32_t RO, RH, RV, GO, GH, GV, BO, BH, BV;
 
-   RO = R_VAL(&Ocol);
-   RH = R_VAL(&Hcol);
-   RV = R_VAL(&Vcol);
-   GO = G_VAL(&Ocol);
-   GH = G_VAL(&Hcol);
-   GV = G_VAL(&Vcol);
-   BO = B_VAL(&Ocol);
-   BH = B_VAL(&Hcol);
-   BV = B_VAL(&Vcol);
+   RO = R_VAL(Ocol);
+   RH = R_VAL(Hcol);
+   RV = R_VAL(Vcol);
+   GO = G_VAL(Ocol);
+   GH = G_VAL(Hcol);
+   GV = G_VAL(Vcol);
+   BO = B_VAL(Ocol);
+   BH = B_VAL(Hcol);
+   BV = B_VAL(Vcol);
 
    if (write)
      {
@@ -908,19 +896,19 @@ _etc2_planar_mode_block_encode(uint8_t *etc2, const uint32_t *bgra,
     * We extrapolate the values from (0,3) and (3,0).
     */
 
-   RO = R_VAL(&(bgra[0]));
-   GO = G_VAL(&(bgra[0]));
-   BO = B_VAL(&(bgra[0]));
+   RO = R_VAL((bgra[0]));
+   GO = G_VAL((bgra[0]));
+   BO = B_VAL((bgra[0]));
    Ocol = _color_reduce_676(bgra[0]);
 
-   Rx = CLAMP(RO + (4 * (R_VAL(&(bgra[3])) - RO)) / 3);
-   Gx = CLAMP(GO + (4 * (G_VAL(&(bgra[3])) - GO)) / 3);
-   Bx = CLAMP(BO + (4 * (B_VAL(&(bgra[3])) - BO)) / 3);
+   Rx = CLAMP(RO + (4 * (R_VAL((bgra[3])) - RO)) / 3);
+   Gx = CLAMP(GO + (4 * (G_VAL((bgra[3])) - GO)) / 3);
+   Bx = CLAMP(BO + (4 * (B_VAL((bgra[3])) - BO)) / 3);
    Hcol = _color_reduce_676(BGRA(Rx, Gx, Bx, 0xFF));
 
-   Rx = CLAMP(RO + (4 * (R_VAL(&(bgra[12])) - RO)) / 3);
-   Gx = CLAMP(GO + (4 * (G_VAL(&(bgra[12])) - GO)) / 3);
-   Bx = CLAMP(BO + (4 * (B_VAL(&(bgra[12])) - BO)) / 3);
+   Rx = CLAMP(RO + (4 * (R_VAL((bgra[12])) - RO)) / 3);
+   Gx = CLAMP(GO + (4 * (G_VAL((bgra[12])) - GO)) / 3);
+   Bx = CLAMP(BO + (4 * (B_VAL((bgra[12])) - BO)) / 3);
    Vcol = _color_reduce_676(BGRA(Rx, Gx, Bx, 0xFF));
 
    err = _etc2_planar_mode_block_pack(etc2, Ocol, Hcol, Vcol, bgra, EINA_TRUE);