Re-enable several MSVC warnings

core/fxge/dib/fx_dib_composite.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxge/dib/dib_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
 
@@ skipping 182 matching lines @@
     *mid = (*mid - *min) * s / (*max - *min);
     *max = s;
     *min = 0;
   }
   return color;
 }
 void _RGB_Blend(int blend_mode,
                 const uint8_t* src_scan,
                 uint8_t* dest_scan,
                 int results[3]) {
-  _RGB src, back, result;
+  _RGB src;
+  _RGB back;
+  _RGB result = {0, 0, 0};
   src.red = src_scan[2];
   src.green = src_scan[1];
   src.blue = src_scan[0];
   back.red = dest_scan[2];
   back.green = dest_scan[1];
   back.blue = dest_scan[0];
   switch (blend_mode) {
     case FXDIB_BLEND_HUE:
       result = _SetLum(_SetSat(src, _Sat(back)), _Lum(back));
       break;
@@ skipping 70 matching lines @@
                               const uint8_t* clip_scan,
                               const uint8_t* src_alpha_scan,
                               uint8_t* dst_alpha_scan,
                               void* pIccTransform) {
   ICodec_IccModule* pIccModule = nullptr;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int blended_color;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         uint8_t back_alpha = *dst_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = *src_alpha_scan++;
           if (clip_scan)
             src_alpha = clip_scan[col] * src_alpha / 255;
 
           if (src_alpha) {
             if (pIccTransform) {
@@ skipping 20 matching lines @@
           continue;
         }
         *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
         int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
         uint8_t gray;
         if (pIccTransform) {
           pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
         } else {
           gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
         }
-        if (bNonseparableBlend) {
-          blended_color =
-              blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        }
-        gray = bNonseparableBlend ? blended_color
-                                  : _BLEND(blend_type, *dest_scan, gray);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = _BLEND(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 3;
       }
     } else {
       for (int col = 0; col < pixel_count; col++) {
         uint8_t back_alpha = *dst_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = src_scan[3];
@@ skipping 140 matching lines @@
                                     const uint8_t* clip_scan,
                                     const uint8_t* src_alpha_scan,
                                     void* pIccTransform) {
   ICodec_IccModule* pIccModule = NULL;
   uint8_t gray;
   if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
 
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int blended_color;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         int src_alpha = *src_alpha_scan++;
         if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
 
         if (src_alpha) {
           if (pIccTransform)
             pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
           else
             gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
 
-          if (bNonseparableBlend) {
-            blended_color =
-                blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-          }
-          gray = bNonseparableBlend ? blended_color
-                                    : _BLEND(blend_type, *dest_scan, gray);
+          if (bNonseparableBlend)
+            gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+          else
+            gray = _BLEND(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
         src_scan += 3;
       }
     } else {
       for (int col = 0; col < pixel_count; col++) {
         int src_alpha = src_scan[3];
         if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
 
         if (src_alpha) {
           if (pIccTransform)
             pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
           else
             gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
 
-          if (bNonseparableBlend) {
-            blended_color =
-                blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-          }
-          gray = bNonseparableBlend ? blended_color
-                                    : _BLEND(blend_type, *dest_scan, gray);
+          if (bNonseparableBlend)
+            gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+          else
+            gray = _BLEND(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
         src_scan += 4;
       }
     }
     return;
   }
   if (src_alpha_scan) {
     for (int col = 0; col < pixel_count; col++) {
@@ skipping 39 matching lines @@
                                    int blend_type,
                                    const uint8_t* clip_scan,
                                    void* pIccTransform) {
   ICodec_IccModule* pIccModule = NULL;
   uint8_t gray;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int blended_color;
     for (int col = 0; col < pixel_count; col++) {
       if (pIccTransform) {
         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
       } else {
         gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
       }
-      if (bNonseparableBlend) {
-        blended_color =
-            blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      }
-      gray = bNonseparableBlend ? blended_color
-                                : _BLEND(blend_type, *dest_scan, gray);
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = _BLEND(blend_type, *dest_scan, gray);
       if (clip_scan && clip_scan[col] < 255) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
       } else {
         *dest_scan = gray;
       }
       dest_scan++;
       src_scan += src_Bpp;
     }
     return;
   }
@@ skipping 18 matching lines @@
                              int pixel_count,
                              int blend_type,
                              const uint8_t* clip_scan,
                              uint8_t* dest_alpha_scan,
                              void* pIccTransform) {
   ICodec_IccModule* pIccModule = NULL;
   if (pIccTransform) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
   if (blend_type) {
-    int blended_color;
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col++) {
       int back_alpha = *dest_alpha_scan;
       if (back_alpha == 0) {
         if (pIccTransform) {
           pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan, 1);
         } else {
           *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
         }
         dest_scan++;
@@ skipping 14 matching lines @@
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
       *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       uint8_t gray;
       if (pIccTransform) {
         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
       } else {
         gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
       }
-      if (bNonseparableBlend) {
-        blended_color =
-            blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      }
-      gray = bNonseparableBlend ? blended_color
-                                : _BLEND(blend_type, *dest_scan, gray);
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = _BLEND(blend_type, *dest_scan, gray);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
       src_scan += src_Bpp;
     }
     return;
   }
   for (int col = 0; col < pixel_count; col++) {
     int src_alpha = 255;
     if (clip_scan) {
       src_alpha = clip_scan[col];
@@ skipping 1138 matching lines @@
 inline void _CompositeRow_8bppPal2Gray(uint8_t* dest_scan,
                                        const uint8_t* src_scan,
                                        const uint8_t* pPalette,
                                        int pixel_count,
                                        int blend_type,
                                        const uint8_t* clip_scan,
                                        const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     if (blend_type) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      int blended_color;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
         int src_alpha = *src_alpha_scan++;
         if (clip_scan) {
           src_alpha = clip_scan[col] * src_alpha / 255;
         }
-        if (bNonseparableBlend) {
-          blended_color =
-              blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        }
-        gray = bNonseparableBlend ? blended_color
-                                  : _BLEND(blend_type, *dest_scan, gray);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = _BLEND(blend_type, *dest_scan, gray);
         if (src_alpha) {
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         } else {
           *dest_scan = gray;
         }
         dest_scan++;
         src_scan++;
       }
       return;
     }
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray = pPalette[*src_scan];
       int src_alpha = *src_alpha_scan++;
       if (clip_scan) {
         src_alpha = clip_scan[col] * src_alpha / 255;
       }
       if (src_alpha) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
       } else {
         *dest_scan = gray;
       }
       dest_scan++;
       src_scan++;
     }
   } else {
     if (blend_type) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      int blended_color;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
-        if (bNonseparableBlend) {
-          blended_color =
-              blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        }
-        gray = bNonseparableBlend ? blended_color
-                                  : _BLEND(blend_type, *dest_scan, gray);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = _BLEND(blend_type, *dest_scan, gray);
         if (clip_scan && clip_scan[col] < 255) {
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
         } else {
           *dest_scan = gray;
         }
         dest_scan++;
         src_scan++;
       }
       return;
     }
@@ skipping 13 matching lines @@
                                         const uint8_t* src_scan,
                                         const uint8_t* pPalette,
                                         int pixel_count,
                                         int blend_type,
                                         const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan,
                                         const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     if (blend_type) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      int blended_color;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
         src_scan++;
         uint8_t back_alpha = *dest_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = *src_alpha_scan++;
           if (clip_scan) {
             src_alpha = clip_scan[col] * src_alpha / 255;
           }
           if (src_alpha) {
             *dest_scan = gray;
             *dest_alpha_scan = src_alpha;
           }
           dest_scan++;
           dest_alpha_scan++;
           continue;
         }
         uint8_t src_alpha = *src_alpha_scan++;
         if (clip_scan) {
           src_alpha = clip_scan[col] * src_alpha / 255;
         }
         if (src_alpha == 0) {
           dest_scan++;
           dest_alpha_scan++;
           continue;
         }
         *dest_alpha_scan =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
-        if (bNonseparableBlend) {
-          blended_color =
-              blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        }
-        gray = bNonseparableBlend ? blended_color
-                                  : _BLEND(blend_type, *dest_scan, gray);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = _BLEND(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_alpha_scan++;
         dest_scan++;
       }
       return;
     }
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray = pPalette[*src_scan];
       src_scan++;
       uint8_t back_alpha = *dest_alpha_scan;
@@ skipping 21 matching lines @@
       }
       *dest_alpha_scan = back_alpha + src_alpha - back_alpha * src_alpha / 255;
       int alpha_ratio = src_alpha * 255 / (*dest_alpha_scan);
       dest_alpha_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
     }
   } else {
     if (blend_type) {
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-      int blended_color;
       for (int col = 0; col < pixel_count; col++) {
         uint8_t gray = pPalette[*src_scan];
         src_scan++;
         if (!clip_scan || clip_scan[col] == 255) {
           *dest_scan++ = gray;
           *dest_alpha_scan++ = 255;
           continue;
         }
         int src_alpha = clip_scan[col];
         if (src_alpha == 0) {
           dest_scan++;
           dest_alpha_scan++;
           continue;
         }
         int back_alpha = *dest_alpha_scan;
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
-        if (bNonseparableBlend) {
-          blended_color =
-              blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-        }
-        gray = bNonseparableBlend ? blended_color
-                                  : _BLEND(blend_type, *dest_scan, gray);
+        if (bNonseparableBlend)
+          gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+        else
+          gray = _BLEND(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
       }
       return;
     }
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray = pPalette[*src_scan];
       src_scan++;
       if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = gray;
@@ skipping 20 matching lines @@
                                        const uint8_t* src_scan,
                                        int src_left,
                                        const uint8_t* pPalette,
                                        int pixel_count,
                                        int blend_type,
                                        const uint8_t* clip_scan) {
   int reset_gray = pPalette[0];
   int set_gray = pPalette[1];
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int blended_color;
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray =
           (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
               ? set_gray
               : reset_gray;
-      if (bNonseparableBlend) {
-        blended_color =
-            blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      }
-      gray = bNonseparableBlend ? blended_color
-                                : _BLEND(blend_type, *dest_scan, gray);
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = _BLEND(blend_type, *dest_scan, gray);
       if (clip_scan && clip_scan[col] < 255) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, clip_scan[col]);
       } else {
         *dest_scan = gray;
       }
       dest_scan++;
     }
     return;
   }
   for (int col = 0; col < pixel_count; col++) {
@@ skipping 14 matching lines @@
                                         int src_left,
                                         const uint8_t* pPalette,
                                         int pixel_count,
                                         int blend_type,
                                         const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan) {
   int reset_gray = pPalette[0];
   int set_gray = pPalette[1];
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-    int blended_color;
     for (int col = 0; col < pixel_count; col++) {
       uint8_t gray =
           (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
               ? set_gray
               : reset_gray;
       if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = gray;
         *dest_alpha_scan++ = 255;
         continue;
       }
       int src_alpha = clip_scan[col];
       if (src_alpha == 0) {
         dest_scan++;
         dest_alpha_scan++;
         continue;
       }
       int back_alpha = *dest_alpha_scan;
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
       *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
-      if (bNonseparableBlend) {
-        blended_color =
-            blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
-      }
-      gray = bNonseparableBlend ? blended_color
-                                : _BLEND(blend_type, *dest_scan, gray);
+      if (bNonseparableBlend)
+        gray = blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
+      else
+        gray = _BLEND(blend_type, *dest_scan, gray);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
     }
     return;
   }
   for (int col = 0; col < pixel_count; col++) {
     uint8_t gray =
         (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8)))
             ? set_gray
             : reset_gray;
@@ skipping 3040 matching lines @@
   }
   src_alpha_scan = m_pScanlineAlphaV;
   dest_alpha_scan = dest_alpha_buf;
   if (dest_alpha_scan) {
     for (i = 0; i < m_DestHeight; i++) {
       *dest_alpha_scan = *src_alpha_scan++;
       dest_alpha_scan += y_alpha_step;
     }
   }
 }