Get rid of most instance of 'foo == NULL'

core/src/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/include/fxge/fx_ge.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 
@@ skipping 719 matching lines @@
 }
 void _CompositeRow_Argb2Argb(uint8_t* dest_scan,
                              const uint8_t* src_scan,
                              int pixel_count,
                              int blend_type,
                              const uint8_t* clip_scan,
                              uint8_t* dest_alpha_scan,
                              const uint8_t* src_alpha_scan) {
   int blended_colors[3];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
-  if (dest_alpha_scan == NULL) {
-    if (src_alpha_scan == NULL) {
+  if (!dest_alpha_scan) {
+    if (!src_alpha_scan) {
       uint8_t back_alpha = 0;
       for (int col = 0; col < pixel_count; col++) {
         back_alpha = dest_scan[3];
         if (back_alpha == 0) {
           if (clip_scan) {
             int src_alpha = clip_scan[col] * src_scan[3] / 255;
             FXARGB_SETDIB(dest_scan, (FXARGB_GETDIB(src_scan) & 0xffffff) |
                                          (src_alpha << 24));
           } else {
             FXARGB_COPY(dest_scan, src_scan);
           }
           dest_scan += 4;
           src_scan += 4;
           continue;
         }
         uint8_t src_alpha;
-        if (clip_scan == NULL) {
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * src_scan[3] / 255;
+        } else {
           src_alpha = src_scan[3];
-        } else {
-          src_alpha = clip_scan[col] * src_scan[3] / 255;
         }
         if (src_alpha == 0) {
           dest_scan += 4;
           src_scan += 4;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
@@ skipping 28 matching lines @@
             FXARGB_SETDIB(dest_scan,
                           FXARGB_MAKE((*src_alpha_scan << 24), src_scan[2],
                                       src_scan[1], *src_scan));
           }
           dest_scan += 4;
           src_scan += 3;
           src_alpha_scan++;
           continue;
         }
         uint8_t src_alpha;
-        if (clip_scan == NULL) {
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
+        } else {
           src_alpha = *src_alpha_scan++;
-        } else {
-          src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
         }
         if (src_alpha == 0) {
           dest_scan += 4;
           src_scan += 3;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
@@ skipping 31 matching lines @@
             *dest_alpha_scan = *src_alpha_scan;
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
           }
           dest_alpha_scan++;
           src_alpha_scan++;
           continue;
         }
         uint8_t src_alpha;
-        if (clip_scan == NULL) {
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
+        } else {
           src_alpha = *src_alpha_scan++;
-        } else {
-          src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
         }
         if (src_alpha == 0) {
           dest_scan += 3;
           src_scan += 3;
           dest_alpha_scan++;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
@@ skipping 29 matching lines @@
             *dest_alpha_scan = src_scan[3];
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
             *dest_scan++ = *src_scan++;
           }
           dest_alpha_scan++;
           src_scan++;
           continue;
         }
         uint8_t src_alpha;
-        if (clip_scan == NULL) {
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * src_scan[3] / 255;
+        } else {
           src_alpha = src_scan[3];
-        } else {
-          src_alpha = clip_scan[col] * src_scan[3] / 255;
         }
         if (src_alpha == 0) {
           dest_scan += 3;
           src_scan += 4;
           dest_alpha_scan++;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         *dest_alpha_scan++ = dest_alpha;
@@ skipping 21 matching lines @@
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan,
                                          const uint8_t* src_scan,
                                          int width,
                                          int blend_type,
                                          int src_Bpp,
                                          uint8_t* dest_alpha_scan) {
   int blended_colors[3];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
-  if (dest_alpha_scan == NULL) {
+  if (dest_alpha_scan) {
     for (int col = 0; col < width; col++) {
-      uint8_t back_alpha = dest_scan[3];
+      uint8_t back_alpha = *dest_alpha_scan;
       if (back_alpha == 0) {
-        if (src_Bpp == 4) {
-          FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
-        } else {
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1],
-                                               src_scan[0]));
-        }
-        dest_scan += 4;
-        src_scan += src_Bpp;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_scan++ = *src_scan++;
+        *dest_alpha_scan++ = 0xff;
+        src_scan += src_gap;
         continue;
       }
-      dest_scan[3] = 0xff;
+      *dest_alpha_scan++ = 0xff;
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int src_color = *src_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, *dest_scan, src_color);
         *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         dest_scan++;
         src_scan++;
       }
-      dest_scan++;
       src_scan += src_gap;
     }
   } else {
     for (int col = 0; col < width; col++) {
-      uint8_t back_alpha = *dest_alpha_scan;
+      uint8_t back_alpha = dest_scan[3];
       if (back_alpha == 0) {
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_scan++ = *src_scan++;
-        *dest_alpha_scan++ = 0xff;
-        src_scan += src_gap;
+        if (src_Bpp == 4) {
+          FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
+        } else {
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[2], src_scan[1],
+                                               src_scan[0]));
+        }
+        dest_scan += 4;
+        src_scan += src_Bpp;
         continue;
       }
-      *dest_alpha_scan++ = 0xff;
+      dest_scan[3] = 0xff;
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int src_color = *src_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, *dest_scan, src_color);
         *dest_scan = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         dest_scan++;
         src_scan++;
       }
+      dest_scan++;
       src_scan += src_gap;
     }
   }
 }
 inline void _CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan,
                                               const uint8_t* src_scan,
                                               int width,
                                               int blend_type,
                                               int src_Bpp,
                                               const uint8_t* clip_scan,
                                               uint8_t* dest_alpha_scan) {
   int blended_colors[3];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int src_gap = src_Bpp - 3;
-  if (dest_alpha_scan == NULL) {
+  if (dest_alpha_scan) {
     for (int col = 0; col < width; col++) {
       int src_alpha = *clip_scan++;
-      uint8_t back_alpha = dest_scan[3];
+      uint8_t back_alpha = *dest_alpha_scan;
       if (back_alpha == 0) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         src_scan += src_gap;
-        dest_scan++;
+        dest_alpha_scan++;
         continue;
       }
       if (src_alpha == 0) {
-        dest_scan += 4;
+        dest_scan += 3;
+        dest_alpha_scan++;
         src_scan += src_Bpp;
         continue;
       }
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      dest_scan[3] = dest_alpha;
+      *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int src_color = *src_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, *dest_scan, src_color);
         blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
         dest_scan++;
         src_scan++;
       }
-      dest_scan++;
       src_scan += src_gap;
     }
   } else {
     for (int col = 0; col < width; col++) {
       int src_alpha = *clip_scan++;
-      uint8_t back_alpha = *dest_alpha_scan;
+      uint8_t back_alpha = dest_scan[3];
       if (back_alpha == 0) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         src_scan += src_gap;
-        dest_alpha_scan++;
+        dest_scan++;
         continue;
       }
       if (src_alpha == 0) {
-        dest_scan += 3;
-        dest_alpha_scan++;
+        dest_scan += 4;
         src_scan += src_Bpp;
         continue;
       }
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      *dest_alpha_scan++ = dest_alpha;
+      dest_scan[3] = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int src_color = *src_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, *dest_scan, src_color);
         blended = FXDIB_ALPHA_MERGE(src_color, blended, back_alpha);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, alpha_ratio);
         dest_scan++;
         src_scan++;
       }
+      dest_scan++;
       src_scan += src_gap;
     }
   }
 }
 inline void _CompositeRow_Rgb2Argb_NoBlend_Clip(uint8_t* dest_scan,
                                                 const uint8_t* src_scan,
                                                 int width,
                                                 int src_Bpp,
                                                 const uint8_t* clip_scan,
                                                 uint8_t* dest_alpha_scan) {
   int src_gap = src_Bpp - 3;
-  if (dest_alpha_scan == NULL) {
+  if (dest_alpha_scan) {
     for (int col = 0; col < width; col++) {
       int src_alpha = clip_scan[col];
       if (src_alpha == 255) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
-        *dest_scan++ = 255;
+        *dest_alpha_scan++ = 255;
         src_scan += src_gap;
         continue;
       }
       if (src_alpha == 0) {
-        dest_scan += 4;
+        dest_scan += 3;
+        dest_alpha_scan++;
         src_scan += src_Bpp;
         continue;
       }
-      int back_alpha = dest_scan[3];
+      int back_alpha = *dest_alpha_scan;
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      dest_scan[3] = dest_alpha;
+      *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       for (int color = 0; color < 3; color++) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
         dest_scan++;
         src_scan++;
       }
-      dest_scan++;
       src_scan += src_gap;
     }
   } else {
     for (int col = 0; col < width; col++) {
       int src_alpha = clip_scan[col];
       if (src_alpha == 255) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
-        *dest_alpha_scan++ = 255;
+        *dest_scan++ = 255;
         src_scan += src_gap;
         continue;
       }
       if (src_alpha == 0) {
-        dest_scan += 3;
-        dest_alpha_scan++;
+        dest_scan += 4;
         src_scan += src_Bpp;
         continue;
       }
-      int back_alpha = *dest_alpha_scan;
+      int back_alpha = dest_scan[3];
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
-      *dest_alpha_scan++ = dest_alpha;
+      dest_scan[3] = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       for (int color = 0; color < 3; color++) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, alpha_ratio);
         dest_scan++;
         src_scan++;
       }
+      dest_scan++;
       src_scan += src_gap;
     }
   }
 }
 inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip(uint8_t* dest_scan,
                                                   const uint8_t* src_scan,
                                                   int width,
                                                   int src_Bpp,
                                                   uint8_t* dest_alpha_scan) {
-  if (dest_alpha_scan == NULL) {
+  if (dest_alpha_scan) {
+    int src_gap = src_Bpp - 3;
+    for (int col = 0; col < width; col++) {
+      *dest_scan++ = *src_scan++;
+      *dest_scan++ = *src_scan++;
+      *dest_scan++ = *src_scan++;
+      *dest_alpha_scan++ = 0xff;
+      src_scan += src_gap;
+    }
+  } else {
     for (int col = 0; col < width; col++) {
       if (src_Bpp == 4) {
         FXARGB_SETDIB(dest_scan, 0xff000000 | FXARGB_GETDIB(src_scan));
       } else {
         FXARGB_SETDIB(dest_scan,
                       FXARGB_MAKE(0xff, src_scan[2], src_scan[1], src_scan[0]));
       }
       dest_scan += 4;
       src_scan += src_Bpp;
     }
-  } else {
-    int src_gap = src_Bpp - 3;
-    for (int col = 0; col < width; col++) {
-      *dest_scan++ = *src_scan++;
-      *dest_scan++ = *src_scan++;
-      *dest_scan++ = *src_scan++;
-      *dest_alpha_scan++ = 0xff;
-      src_scan += src_gap;
-    }
   }
 }
 inline void _CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan,
                                          const uint8_t* src_scan,
                                          int width,
                                          int blend_type,
                                          int dest_Bpp,
                                          const uint8_t* clip_scan,
                                          const uint8_t* src_alpha_scan) {
   int blended_colors[3];
   FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
   int dest_gap = dest_Bpp - 3;
-  if (src_alpha_scan == NULL) {
+  if (src_alpha_scan) {
     for (int col = 0; col < width; col++) {
       uint8_t src_alpha;
       if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
       } else {
-        src_alpha = src_scan[3];
+        src_alpha = *src_alpha_scan++;
       }
       if (src_alpha == 0) {
         dest_scan += dest_Bpp;
-        src_scan += 4;
+        src_scan += 3;
         continue;
       }
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int back_color = *dest_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, back_color, *src_scan);
         *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
         dest_scan++;
         src_scan++;
       }
       dest_scan += dest_gap;
-      src_scan++;
     }
   } else {
     for (int col = 0; col < width; col++) {
       uint8_t src_alpha;
       if (clip_scan) {
-        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
       } else {
-        src_alpha = *src_alpha_scan++;
+        src_alpha = src_scan[3];
       }
       if (src_alpha == 0) {
         dest_scan += dest_Bpp;
-        src_scan += 3;
+        src_scan += 4;
         continue;
       }
       if (bNonseparableBlend) {
         _RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
       }
       for (int color = 0; color < 3; color++) {
         int back_color = *dest_scan;
         int blended = bNonseparableBlend
                           ? blended_colors[color]
                           : _BLEND(blend_type, back_color, *src_scan);
         *dest_scan = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
         dest_scan++;
         src_scan++;
       }
       dest_scan += dest_gap;
+      src_scan++;
     }
   }
 }
 inline void _CompositeRow_Argb2Rgb_NoBlend(uint8_t* dest_scan,
                                            const uint8_t* src_scan,
                                            int width,
                                            int dest_Bpp,
                                            const uint8_t* clip_scan,
                                            const uint8_t* src_alpha_scan) {
   int dest_gap = dest_Bpp - 3;
-  if (src_alpha_scan == NULL) {
+  if (src_alpha_scan) {
     for (int col = 0; col < width; col++) {
       uint8_t src_alpha;
       if (clip_scan) {
-        src_alpha = src_scan[3] * (*clip_scan++) / 255;
+        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
       } else {
-        src_alpha = src_scan[3];
+        src_alpha = *src_alpha_scan++;
       }
       if (src_alpha == 255) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         dest_scan += dest_gap;
-        src_scan++;
         continue;
       }
       if (src_alpha == 0) {
         dest_scan += dest_Bpp;
-        src_scan += 4;
+        src_scan += 3;
         continue;
       }
       for (int color = 0; color < 3; color++) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
         dest_scan++;
         src_scan++;
       }
       dest_scan += dest_gap;
-      src_scan++;
     }
   } else {
     for (int col = 0; col < width; col++) {
       uint8_t src_alpha;
       if (clip_scan) {
-        src_alpha = (*src_alpha_scan++) * (*clip_scan++) / 255;
+        src_alpha = src_scan[3] * (*clip_scan++) / 255;
       } else {
-        src_alpha = *src_alpha_scan++;
+        src_alpha = src_scan[3];
       }
       if (src_alpha == 255) {
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         *dest_scan++ = *src_scan++;
         dest_scan += dest_gap;
+        src_scan++;
         continue;
       }
       if (src_alpha == 0) {
         dest_scan += dest_Bpp;
-        src_scan += 3;
+        src_scan += 4;
         continue;
       }
       for (int color = 0; color < 3; color++) {
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, *src_scan, src_alpha);
         dest_scan++;
         src_scan++;
       }
       dest_scan += dest_gap;
+      src_scan++;
     }
   }
 }
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan,
                                                const uint8_t* src_scan,
                                                int width,
                                                int blend_type,
                                                int dest_Bpp,
                                                int src_Bpp) {
   int blended_colors[3];
@@ skipping 104 matching lines @@
                                        int blend_type,
                                        const uint8_t* clip_scan,
                                        uint8_t* dest_alpha_scan,
                                        const uint8_t* src_alpha_scan,
                                        uint8_t* src_cache_scan,
                                        void* pIccTransform) {
   uint8_t* dp = src_cache_scan;
   ICodec_IccModule* pIccModule =
       CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   if (src_alpha_scan) {
-    if (dest_alpha_scan == NULL) {
+    if (dest_alpha_scan) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count);
+    } else {
       for (int col = 0; col < pixel_count; col++) {
         pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
         dp[3] = *src_alpha_scan++;
         src_scan += 3;
         dp += 4;
       }
       src_alpha_scan = NULL;
-    } else {
-      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, pixel_count);
     }
   } else {
-    if (dest_alpha_scan == NULL) {
-      for (int col = 0; col < pixel_count; col++) {
-        pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
-        dp[3] = src_scan[3];
-        src_scan += 4;
-        dp += 4;
-      }
-    } else {
+    if (dest_alpha_scan) {
       int blended_colors[3];
       FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
       for (int col = 0; col < pixel_count; col++) {
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan,
                                       1);
         uint8_t back_alpha = *dest_alpha_scan;
         if (back_alpha == 0) {
           if (clip_scan) {
             int src_alpha = clip_scan[col] * src_scan[3] / 255;
             *dest_alpha_scan = src_alpha;
             *dest_scan++ = *src_cache_scan++;
             *dest_scan++ = *src_cache_scan++;
             *dest_scan++ = *src_cache_scan++;
           } else {
             *dest_alpha_scan = src_scan[3];
             *dest_scan++ = *src_cache_scan++;
             *dest_scan++ = *src_cache_scan++;
             *dest_scan++ = *src_cache_scan++;
           }
           dest_alpha_scan++;
           src_scan += 4;
           continue;
         }
         uint8_t src_alpha;
-        if (clip_scan == NULL) {
+        if (clip_scan) {
+          src_alpha = clip_scan[col] * src_scan[3] / 255;
+        } else {
           src_alpha = src_scan[3];
-        } else {
-          src_alpha = clip_scan[col] * src_scan[3] / 255;
         }
         src_scan += 4;
         if (src_alpha == 0) {
           dest_scan += 3;
           src_cache_scan += 3;
           dest_alpha_scan++;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
@@ skipping 12 matching lines @@
           } else {
             *dest_scan =
                 FXDIB_ALPHA_MERGE(*dest_scan, *src_cache_scan, alpha_ratio);
           }
           dest_scan++;
           src_cache_scan++;
         }
       }
       return;
     }
+    for (int col = 0; col < pixel_count; col++) {
+      pIccModule->TranslateScanline(pIccTransform, dp, src_scan, 1);
+      dp[3] = src_scan[3];
+      src_scan += 4;
+      dp += 4;
+    }
   }
   _CompositeRow_Argb2Argb(dest_scan, src_cache_scan, pixel_count, blend_type,
                           clip_scan, dest_alpha_scan, src_alpha_scan);
 }
 void _CompositeRow_Rgb2Argb_Blend_NoClip_Transform(uint8_t* dest_scan,
                                                    const uint8_t* src_scan,
                                                    int width,
                                                    int blend_type,
                                                    int src_Bpp,
                                                    uint8_t* dest_alpha_scan,
@@ skipping 456 matching lines @@
       *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 == NULL || clip_scan[col] == 255) {
+        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);
         *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 == NULL || clip_scan[col] == 255) {
+      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;
       }
@@ skipping 63 matching lines @@
   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 == NULL || clip_scan[col] == 255) {
+      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;
       }
@@ skipping 11 matching lines @@
       *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;
-    if (clip_scan == NULL || clip_scan[col] == 255) {
+    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;
     }
@@ skipping 135 matching lines @@
           FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
         } else {
           FXARGB_SETDIB(dest_scan,
                         FXARGB_MAKE(*src_alpha_scan, src_r, src_g, src_b));
         }
         dest_scan += 4;
         src_alpha_scan++;
         continue;
       }
       uint8_t src_alpha;
-      if (clip_scan == NULL) {
+      if (clip_scan) {
+        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
+      } else {
         src_alpha = *src_alpha_scan++;
-      } else {
-        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
       }
       if (src_alpha == 0) {
         dest_scan += 4;
         continue;
       }
       uint8_t dest_alpha =
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
       dest_scan[3] = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
       dest_scan++;
     }
   } else
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
-      if (clip_scan == NULL || clip_scan[col] == 255) {
+      if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = src_b;
         *dest_scan++ = src_g;
         *dest_scan++ = src_r;
         *dest_scan++ = 255;
         src_scan++;
         continue;
       }
       int src_alpha = clip_scan[col];
       if (src_alpha == 0) {
         dest_scan += 4;
@@ skipping 37 matching lines @@
         } else {
           *dest_alpha_scan++ = *src_alpha_scan;
         }
         *dest_scan++ = src_b;
         *dest_scan++ = src_g;
         *dest_scan++ = src_r;
         src_alpha_scan++;
         continue;
       }
       uint8_t src_alpha;
-      if (clip_scan == NULL) {
+      if (clip_scan) {
+        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
+      } else {
         src_alpha = *src_alpha_scan++;
-      } else {
-        src_alpha = clip_scan[col] * (*src_alpha_scan++) / 255;
       }
       if (src_alpha == 0) {
         dest_scan += 3;
         dest_alpha_scan++;
         continue;
       }
       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;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
     }
   } else
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
-      if (clip_scan == NULL || clip_scan[col] == 255) {
+      if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = src_b;
         *dest_scan++ = src_g;
         *dest_scan++ = src_r;
         *dest_alpha_scan++ = 255;
         src_scan++;
         continue;
       }
       int src_alpha = clip_scan[col];
       if (src_alpha == 0) {
         dest_scan += 3;
@@ skipping 33 matching lines @@
     int src_r, src_g, src_b;
     if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
       src_r = set_r;
       src_g = set_g;
       src_b = set_b;
     } else {
       src_r = reset_r;
       src_g = reset_g;
       src_b = reset_b;
     }
-    if (clip_scan == NULL || clip_scan[col] == 255) {
+    if (!clip_scan || clip_scan[col] == 255) {
       *dest_scan++ = src_b;
       *dest_scan++ = src_g;
       *dest_scan++ = src_r;
       *dest_scan++ = 255;
       continue;
     }
     int src_alpha = clip_scan[col];
     if (src_alpha == 0) {
       dest_scan += 4;
       continue;
@@ skipping 30 matching lines @@
     int src_r, src_g, src_b;
     if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
       src_r = set_r;
       src_g = set_g;
       src_b = set_b;
     } else {
       src_r = reset_r;
       src_g = reset_g;
       src_b = reset_b;
     }
-    if (clip_scan == NULL || clip_scan[col] == 255) {
+    if (!clip_scan || clip_scan[col] == 255) {
       *dest_scan++ = src_b;
       *dest_scan++ = src_g;
       *dest_scan++ = src_r;
       *dest_alpha_scan++ = 255;
       continue;
     }
     int src_alpha = clip_scan[col];
     if (src_alpha == 0) {
       dest_scan += 3;
       dest_alpha_scan++;
@@ skipping 276 matching lines @@
 void _CompositeRow_BitMask2Argb(uint8_t* dest_scan,
                                 const uint8_t* src_scan,
                                 int mask_alpha,
                                 int src_r,
                                 int src_g,
                                 int src_b,
                                 int src_left,
                                 int pixel_count,
                                 int blend_type,
                                 const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL &&
-      mask_alpha == 255) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
     FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
     for (int col = 0; col < pixel_count; col++) {
       if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
         FXARGB_SETDIB(dest_scan, argb);
       }
       dest_scan += 4;
     }
     return;
   }
   for (int col = 0; col < pixel_count; col++) {
@@ skipping 57 matching lines @@
                                 const uint8_t* src_scan,
                                 int mask_alpha,
                                 int src_r,
                                 int src_g,
                                 int src_b,
                                 int src_left,
                                 int pixel_count,
                                 int blend_type,
                                 const uint8_t* clip_scan,
                                 uint8_t* dest_alpha_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL &&
-      mask_alpha == 255) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
     for (int col = 0; col < pixel_count; col++) {
       if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
         dest_scan[0] = src_b;
         dest_scan[1] = src_g;
         dest_scan[2] = src_r;
         *dest_alpha_scan = mask_alpha;
       }
       dest_scan += 3;
       dest_alpha_scan++;
     }
@@ skipping 65 matching lines @@
                                const uint8_t* src_scan,
                                int mask_alpha,
                                int src_r,
                                int src_g,
                                int src_b,
                                int src_left,
                                int pixel_count,
                                int blend_type,
                                int Bpp,
                                const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL &&
-      mask_alpha == 255) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
     for (int col = 0; col < pixel_count; col++) {
       if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
         dest_scan[2] = src_r;
         dest_scan[1] = src_g;
         dest_scan[0] = src_b;
       }
       dest_scan += Bpp;
     }
     return;
   }
@@ skipping 148 matching lines @@
         dest_scan[1] = src_scan[1];
         dest_scan[2] = src_scan[0];
       } else {
         FXARGB_RGBORDERCOPY(dest_scan, src_scan);
       }
       dest_scan += 4;
       src_scan += 4;
       continue;
     }
     uint8_t src_alpha;
-    if (clip_scan == NULL) {
+    if (clip_scan) {
+      src_alpha = clip_scan[col] * src_scan[3] / 255;
+    } else {
       src_alpha = src_scan[3];
-    } else {
-      src_alpha = clip_scan[col] * src_scan[3] / 255;
     }
     if (src_alpha == 0) {
       dest_scan += 4;
       src_scan += 4;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     dest_scan[3] = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (bNonseparableBlend) {
@@ skipping 440 matching lines @@
   for (int col = 0; col < width; col++) {
     int src_r, src_g, src_b;
     if (pPalette) {
       FX_ARGB argb = pPalette[*src_scan];
       src_r = FXARGB_R(argb);
       src_g = FXARGB_G(argb);
       src_b = FXARGB_B(argb);
     } else {
       src_r = src_g = src_b = *src_scan;
     }
-    if (clip_scan == NULL || clip_scan[col] == 255) {
+    if (!clip_scan || clip_scan[col] == 255) {
       dest_scan[2] = FX_GAMMA(src_b);
       dest_scan[1] = FX_GAMMA(src_g);
       dest_scan[0] = FX_GAMMA(src_r);
       dest_scan[3] = 255;
       src_scan++;
       dest_scan += 4;
       continue;
     }
     int src_alpha = clip_scan[col];
     if (src_alpha == 0) {
@@ skipping 39 matching lines @@
     int src_r, src_g, src_b;
     if (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) {
       src_r = set_r;
       src_g = set_g;
       src_b = set_b;
     } else {
       src_r = reset_r;
       src_g = reset_g;
       src_b = reset_b;
     }
-    if (clip_scan == NULL || clip_scan[col] == 255) {
+    if (!clip_scan || clip_scan[col] == 255) {
       dest_scan[2] = FX_GAMMA(src_b);
       dest_scan[1] = FX_GAMMA(src_g);
       dest_scan[0] = FX_GAMMA(src_r);
       dest_scan[3] = 255;
       dest_scan += 4;
       continue;
     }
     int src_alpha = clip_scan[col];
     if (src_alpha == 0) {
       dest_scan += 4;
@@ skipping 133 matching lines @@
 void _CompositeRow_BitMask2Argb_RgbByteOrder(uint8_t* dest_scan,
                                              const uint8_t* src_scan,
                                              int mask_alpha,
                                              int src_r,
                                              int src_g,
                                              int src_b,
                                              int src_left,
                                              int pixel_count,
                                              int blend_type,
                                              const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL &&
-      mask_alpha == 255) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
     FX_ARGB argb = FXARGB_MAKE(0xff, src_r, src_g, src_b);
     for (int col = 0; col < pixel_count; col++) {
       if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
         FXARGB_SETRGBORDERDIB(dest_scan, argb);
       }
       dest_scan += 4;
     }
     return;
   }
   for (int col = 0; col < pixel_count; col++) {
@@ skipping 56 matching lines @@
                                             const uint8_t* src_scan,
                                             int mask_alpha,
                                             int src_r,
                                             int src_g,
                                             int src_b,
                                             int src_left,
                                             int pixel_count,
                                             int blend_type,
                                             int Bpp,
                                             const uint8_t* clip_scan) {
-  if (blend_type == FXDIB_BLEND_NORMAL && clip_scan == NULL &&
-      mask_alpha == 255) {
+  if (blend_type == FXDIB_BLEND_NORMAL && !clip_scan && mask_alpha == 255) {
     for (int col = 0; col < pixel_count; col++) {
       if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
         dest_scan[2] = src_b;
         dest_scan[1] = src_g;
         dest_scan[0] = src_r;
       }
       dest_scan += Bpp;
     }
     return;
   }
@@ skipping 278 matching lines @@
                                      int alpha_flag,
                                      void* pIccTransform) {
   m_SrcFormat = src_format;
   m_DestFormat = dest_format;
   m_BlendType = blend_type;
   m_bRgbByteOrder = bRgbByteOrder;
   ICodec_IccModule* pIccModule = NULL;
   if (CFX_GEModule::Get()->GetCodecModule()) {
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
   }
-  if (pIccModule == NULL) {
+  if (!pIccModule) {
     pIccTransform = NULL;
   }
   m_pIccTransform = pIccTransform;
   if ((dest_format & 0xff) == 1) {
     return FALSE;
   }
   if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
     return _ScanlineCompositor_InitSourceMask(
         dest_format, alpha_flag, mask_color, m_MaskAlpha, m_MaskRed,
         m_MaskGreen, m_MaskBlue, m_MaskBlack, pIccModule, pIccTransform);
   }
-  if (pIccTransform == NULL && (~src_format & 0x0400) &&
-      (dest_format & 0x0400)) {
+  if (!pIccTransform && (~src_format & 0x0400) && (dest_format & 0x0400)) {
     return FALSE;
   }
   if ((m_SrcFormat & 0xff) <= 8) {
     if (dest_format == FXDIB_8bppMask) {
       return TRUE;
     }
     _ScanlineCompositor_InitSourcePalette(src_format, dest_format,
                                           m_pSrcPalette, pSrcPalette,
                                           pIccModule, pIccTransform);
     m_Transparency =
@@ skipping 413 matching lines @@
                                       int dest_top,
                                       int width,
                                       int height,
                                       const CFX_DIBSource* pSrcBitmap,
                                       int src_left,
                                       int src_top,
                                       int blend_type,
                                       const CFX_ClipRgn* pClipRgn,
                                       FX_BOOL bRgbByteOrder,
                                       void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(!pSrcBitmap->IsAlphaMask());
   ASSERT(m_bpp >= 8);
   if (pSrcBitmap->IsAlphaMask() || m_bpp < 8) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
                  pSrcBitmap->GetHeight(), src_left, src_top, pClipRgn);
   if (width == 0 || height == 0) {
@@ skipping 52 matching lines @@
                                     int height,
                                     const CFX_DIBSource* pMask,
                                     FX_DWORD color,
                                     int src_left,
                                     int src_top,
                                     int blend_type,
                                     const CFX_ClipRgn* pClipRgn,
                                     FX_BOOL bRgbByteOrder,
                                     int alpha_flag,
                                     void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(pMask->IsAlphaMask());
   ASSERT(m_bpp >= 8);
   if (!pMask->IsAlphaMask() || m_bpp < 8) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
                  pMask->GetHeight(), src_left, src_top, pClipRgn);
   if (width == 0 || height == 0) {
@@ skipping 43 matching lines @@
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::CompositeRect(int left,
                                     int top,
                                     int width,
                                     int height,
                                     FX_DWORD color,
                                     int alpha_flag,
                                     void* pIccTransform) {
-  if (m_pBuffer == NULL) {
+  if (!m_pBuffer) {
     return FALSE;
   }
   int src_alpha = (alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
   if (src_alpha == 0) {
     return TRUE;
   }
   FX_RECT rect(left, top, left + width, top + height);
   rect.Intersect(0, 0, m_Width, m_Height);
   if (rect.IsEmpty()) {
     return TRUE;
@@ skipping 39 matching lines @@
         }
     }
     return TRUE;
   }
   if (m_bpp == 1) {
     ASSERT(!IsCmykImage() && (uint8_t)(alpha_flag >> 8) == 0);
     int left_shift = rect.left % 8;
     int right_shift = rect.right % 8;
     int width = rect.right / 8 - rect.left / 8;
     int index = 0;
-    if (m_pPalette == NULL) {
-      index = ((uint8_t)color == 0xff) ? 1 : 0;
-    } else {
-      for (int i = 0; i < 2; i++)
+    if (m_pPalette) {
+      for (int i = 0; i < 2; i++) {
         if (m_pPalette[i] == color) {
           index = i;
         }
+      }
+    } else {
+      index = ((uint8_t)color == 0xff) ? 1 : 0;
     }
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan_top = (uint8_t*)GetScanline(row) + rect.left / 8;
       uint8_t* dest_scan_top_r = (uint8_t*)GetScanline(row) + rect.right / 8;
       uint8_t left_flag = *dest_scan_top & (255 << (8 - left_shift));
       uint8_t right_flag = *dest_scan_top_r & (255 >> right_shift);
       if (width) {
         FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, width - 1);
         if (!index) {
           *dest_scan_top &= left_flag;
@@ skipping 311 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;
     }
   }
 }