Remove FX_DWORD from core/ and delete definition

core/fxcodec/jbig2/JBig2_Image.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 <limits.h>
 
 #include "core/fxcodec/jbig2/JBig2_Image.h"
 #include "core/fxcrt/include/fx_coordinates.h"
@@ skipping 131 matching lines @@
                                   int32_t y,
                                   CJBig2_Image* pSrc,
                                   JBig2ComposeOp op,
                                   const FX_RECT* pSrcRect) {
   if (!m_pData) {
     return FALSE;
   }
   return pSrc->composeTo(this, x, y, op, pSrcRect);
 }
 #define JBIG2_GETDWORD(buf) \
-  ((FX_DWORD)(((buf)[0] << 24) | ((buf)[1] << 16) | ((buf)[2] << 8) | (buf)[3]))
+  ((uint32_t)(((buf)[0] << 24) | ((buf)[1] << 16) | ((buf)[2] << 8) | (buf)[3]))
 CJBig2_Image* CJBig2_Image::subImage(int32_t x,
                                      int32_t y,
                                      int32_t w,
                                      int32_t h) {
   int32_t m, n, j;
   uint8_t *pLineSrc, *pLineDst;
-  FX_DWORD wTmp;
+  uint32_t wTmp;
   uint8_t *pSrc, *pSrcEnd, *pDst, *pDstEnd;
   if (w == 0 || h == 0) {
     return NULL;
   }
   CJBig2_Image* pImage = new CJBig2_Image(w, h);
   if (!m_pData) {
     pImage->fill(0);
     return pImage;
   }
   if (!pImage->m_pData) {
     return pImage;
   }
   pLineSrc = m_pData + m_nStride * y;
   pLineDst = pImage->m_pData;
   m = (x >> 5) << 2;
   n = x & 31;
   if (n == 0) {
     for (j = 0; j < h; j++) {
       pSrc = pLineSrc + m;
       pSrcEnd = pLineSrc + m_nStride;
       pDst = pLineDst;
       pDstEnd = pLineDst + pImage->m_nStride;
       for (; pDst < pDstEnd; pSrc += 4, pDst += 4) {
-        *((FX_DWORD*)pDst) = *((FX_DWORD*)pSrc);
+        *((uint32_t*)pDst) = *((uint32_t*)pSrc);
       }
       pLineSrc += m_nStride;
       pLineDst += pImage->m_nStride;
     }
   } else {
     for (j = 0; j < h; j++) {
       pSrc = pLineSrc + m;
       pSrcEnd = pLineSrc + m_nStride;
       pDst = pLineDst;
       pDstEnd = pLineDst + pImage->m_nStride;
@@ skipping 12 matching lines @@
       pLineSrc += m_nStride;
       pLineDst += pImage->m_nStride;
     }
   }
   return pImage;
 }
 void CJBig2_Image::expand(int32_t h, FX_BOOL v) {
   if (!m_pData || h <= m_nHeight) {
     return;
   }
-  FX_DWORD dwH = pdfium::base::checked_cast<FX_DWORD>(h);
-  FX_DWORD dwStride = pdfium::base::checked_cast<FX_DWORD>(m_nStride);
-  FX_DWORD dwHeight = pdfium::base::checked_cast<FX_DWORD>(m_nHeight);
+  uint32_t dwH = pdfium::base::checked_cast<uint32_t>(h);
+  uint32_t dwStride = pdfium::base::checked_cast<uint32_t>(m_nStride);
+  uint32_t dwHeight = pdfium::base::checked_cast<uint32_t>(m_nHeight);
   FX_SAFE_DWORD safeMemSize = dwH;
   safeMemSize *= dwStride;
   if (!safeMemSize.IsValid()) {
     return;
   }
   // The guaranteed reallocated memory is to be < 4GB (unsigned int).
   m_pData = FX_Realloc(uint8_t, m_pData, safeMemSize.ValueOrDie());
 
   // The result of dwHeight * dwStride doesn't overflow after the
   // checking of safeMemSize.
   // The same as the result of (dwH - dwHeight) * dwStride) because
   // dwH - dwHeight is always less than dwH(h) which is checked in
   // the calculation of dwH * dwStride.
   JBIG2_memset(m_pData + dwHeight * dwStride, v ? 0xff : 0,
                (dwH - dwHeight) * dwStride);
   m_nHeight = h;
 }
 FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image* pDst,
                                      int32_t x,
                                      int32_t y,
                                      JBig2ComposeOp op) {
   int32_t xs0 = 0, ys0 = 0, xs1 = 0, ys1 = 0, xd0 = 0, yd0 = 0, xd1 = 0,
           yd1 = 0, xx = 0, yy = 0, w = 0, h = 0, middleDwords = 0, lineLeft = 0;
 
-  FX_DWORD s1 = 0, d1 = 0, d2 = 0, shift = 0, shift1 = 0, shift2 = 0, tmp = 0,
+  uint32_t s1 = 0, d1 = 0, d2 = 0, shift = 0, shift1 = 0, shift2 = 0, tmp = 0,
            tmp1 = 0, tmp2 = 0, maskL = 0, maskR = 0, maskM = 0;
 
   uint8_t *lineSrc = NULL, *lineDst = NULL, *sp = NULL, *dp = NULL;
 
   if (!m_pData) {
     return FALSE;
   }
   if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
     return FALSE;
   }
@@ skipping 439 matching lines @@
   int32_t maskL = 0xffffffff >> d1;
   int32_t maskR = 0xffffffff << ((32 - (xd1 & 31)) % 32);
   int32_t maskM = maskL & maskR;
   uint8_t* lineSrc = m_pData + (pSrcRect->top + ys0) * m_nStride +
                      (((xs0 + pSrcRect->left) >> 5) << 2);
   int32_t lineLeft = m_nStride - ((xs0 >> 5) << 2);
   uint8_t* lineDst = pDst->m_pData + yd0 * pDst->m_nStride + ((xd0 >> 5) << 2);
   if ((xd0 & ~31) == ((xd1 - 1) & ~31)) {
     if ((xs0 & ~31) == ((xs1 - 1) & ~31)) {
       if (s1 > d1) {
-        FX_DWORD shift = s1 - d1;
+        uint32_t shift = s1 - d1;
         for (int32_t yy = yd0; yy < yd1; yy++) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
-          FX_DWORD tmp2 = JBIG2_GETDWORD(lineDst);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(lineSrc) << shift;
+          uint32_t tmp2 = JBIG2_GETDWORD(lineDst);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
               break;
           }
           lineDst[0] = (uint8_t)(tmp >> 24);
           lineDst[1] = (uint8_t)(tmp >> 16);
           lineDst[2] = (uint8_t)(tmp >> 8);
           lineDst[3] = (uint8_t)tmp;
           lineSrc += m_nStride;
           lineDst += pDst->m_nStride;
         }
       } else {
-        FX_DWORD shift = d1 - s1;
+        uint32_t shift = d1 - s1;
         for (int32_t yy = yd0; yy < yd1; yy++) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
-          FX_DWORD tmp2 = JBIG2_GETDWORD(lineDst);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(lineSrc) >> shift;
+          uint32_t tmp2 = JBIG2_GETDWORD(lineDst);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
               break;
           }
           lineDst[0] = (uint8_t)(tmp >> 24);
           lineDst[1] = (uint8_t)(tmp >> 16);
           lineDst[2] = (uint8_t)(tmp >> 8);
           lineDst[3] = (uint8_t)tmp;
           lineSrc += m_nStride;
           lineDst += pDst->m_nStride;
         }
       }
     } else {
-      FX_DWORD shift1 = s1 - d1;
-      FX_DWORD shift2 = 32 - shift1;
+      uint32_t shift1 = s1 - d1;
+      uint32_t shift2 = 32 - shift1;
       for (int32_t yy = yd0; yy < yd1; yy++) {
-        FX_DWORD tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) |
+        uint32_t tmp1 = (JBIG2_GETDWORD(lineSrc) << shift1) |
                         (JBIG2_GETDWORD(lineSrc + 4) >> shift2);
-        FX_DWORD tmp2 = JBIG2_GETDWORD(lineDst);
-        FX_DWORD tmp = 0;
+        uint32_t tmp2 = JBIG2_GETDWORD(lineDst);
+        uint32_t tmp = 0;
         switch (op) {
           case JBIG2_COMPOSE_OR:
             tmp = (tmp2 & ~maskM) | ((tmp1 | tmp2) & maskM);
             break;
           case JBIG2_COMPOSE_AND:
             tmp = (tmp2 & ~maskM) | ((tmp1 & tmp2) & maskM);
             break;
           case JBIG2_COMPOSE_XOR:
             tmp = (tmp2 & ~maskM) | ((tmp1 ^ tmp2) & maskM);
             break;
           case JBIG2_COMPOSE_XNOR:
             tmp = (tmp2 & ~maskM) | ((~(tmp1 ^ tmp2)) & maskM);
             break;
           case JBIG2_COMPOSE_REPLACE:
             tmp = (tmp2 & ~maskM) | (tmp1 & maskM);
             break;
         }
         lineDst[0] = (uint8_t)(tmp >> 24);
         lineDst[1] = (uint8_t)(tmp >> 16);
         lineDst[2] = (uint8_t)(tmp >> 8);
         lineDst[3] = (uint8_t)tmp;
         lineSrc += m_nStride;
         lineDst += pDst->m_nStride;
       }
     }
   } else {
     if (s1 > d1) {
-      FX_DWORD shift1 = s1 - d1;
-      FX_DWORD shift2 = 32 - shift1;
+      uint32_t shift1 = s1 - d1;
+      uint32_t shift2 = 32 - shift1;
       int32_t middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
       for (int32_t yy = yd0; yy < yd1; yy++) {
         uint8_t* sp = lineSrc;
         uint8_t* dp = lineDst;
         if (d1 != 0) {
-          FX_DWORD tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
+          uint32_t tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
                           (JBIG2_GETDWORD(sp + 4) >> shift2);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           sp += 4;
           dp += 4;
         }
         for (int32_t xx = 0; xx < middleDwords; xx++) {
-          FX_DWORD tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
+          uint32_t tmp1 = (JBIG2_GETDWORD(sp) << shift1) |
                           (JBIG2_GETDWORD(sp + 4) >> shift2);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = tmp1 | tmp2;
               break;
             case JBIG2_COMPOSE_AND:
               tmp = tmp1 & tmp2;
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = tmp1 ^ tmp2;
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = ~(tmp1 ^ tmp2);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = tmp1;
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           sp += 4;
           dp += 4;
         }
         if (d2 != 0) {
-          FX_DWORD tmp1 =
+          uint32_t tmp1 =
               (JBIG2_GETDWORD(sp) << shift1) |
               (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
                shift2);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
               break;
@@ skipping 11 matching lines @@
         }
         lineSrc += m_nStride;
         lineDst += pDst->m_nStride;
       }
     } else if (s1 == d1) {
       int32_t middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
       for (int32_t yy = yd0; yy < yd1; yy++) {
         uint8_t* sp = lineSrc;
         uint8_t* dp = lineDst;
         if (d1 != 0) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(sp);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(sp);
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           sp += 4;
           dp += 4;
         }
         for (int32_t xx = 0; xx < middleDwords; xx++) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(sp);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(sp);
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = tmp1 | tmp2;
               break;
             case JBIG2_COMPOSE_AND:
               tmp = tmp1 & tmp2;
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = tmp1 ^ tmp2;
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = ~(tmp1 ^ tmp2);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = tmp1;
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           sp += 4;
           dp += 4;
         }
         if (d2 != 0) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(sp);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(sp);
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
         }
         lineSrc += m_nStride;
         lineDst += pDst->m_nStride;
       }
     } else {
-      FX_DWORD shift1 = d1 - s1;
-      FX_DWORD shift2 = 32 - shift1;
+      uint32_t shift1 = d1 - s1;
+      uint32_t shift2 = 32 - shift1;
       int32_t middleDwords = (xd1 >> 5) - ((xd0 + 31) >> 5);
       for (int32_t yy = yd0; yy < yd1; yy++) {
         uint8_t* sp = lineSrc;
         uint8_t* dp = lineDst;
         if (d1 != 0) {
-          FX_DWORD tmp1 = JBIG2_GETDWORD(sp) >> shift1;
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp1 = JBIG2_GETDWORD(sp) >> shift1;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskL) | ((tmp1 | tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskL) | ((tmp1 & tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskL) | ((tmp1 ^ tmp2) & maskL);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskL) | ((~(tmp1 ^ tmp2)) & maskL);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskL) | (tmp1 & maskL);
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           dp += 4;
         }
         for (int32_t xx = 0; xx < middleDwords; xx++) {
-          FX_DWORD tmp1 = (JBIG2_GETDWORD(sp) << shift2) |
+          uint32_t tmp1 = (JBIG2_GETDWORD(sp) << shift2) |
                           ((JBIG2_GETDWORD(sp + 4)) >> shift1);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = tmp1 | tmp2;
               break;
             case JBIG2_COMPOSE_AND:
               tmp = tmp1 & tmp2;
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = tmp1 ^ tmp2;
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = ~(tmp1 ^ tmp2);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = tmp1;
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
           sp += 4;
           dp += 4;
         }
         if (d2 != 0) {
-          FX_DWORD tmp1 =
+          uint32_t tmp1 =
               (JBIG2_GETDWORD(sp) << shift2) |
               (((sp + 4) < lineSrc + lineLeft ? JBIG2_GETDWORD(sp + 4) : 0) >>
                shift1);
-          FX_DWORD tmp2 = JBIG2_GETDWORD(dp);
-          FX_DWORD tmp = 0;
+          uint32_t tmp2 = JBIG2_GETDWORD(dp);
+          uint32_t tmp = 0;
           switch (op) {
             case JBIG2_COMPOSE_OR:
               tmp = (tmp2 & ~maskR) | ((tmp1 | tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_AND:
               tmp = (tmp2 & ~maskR) | ((tmp1 & tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_XOR:
               tmp = (tmp2 & ~maskR) | ((tmp1 ^ tmp2) & maskR);
               break;
             case JBIG2_COMPOSE_XNOR:
               tmp = (tmp2 & ~maskR) | ((~(tmp1 ^ tmp2)) & maskR);
               break;
             case JBIG2_COMPOSE_REPLACE:
               tmp = (tmp2 & ~maskR) | (tmp1 & maskR);
               break;
           }
           dp[0] = (uint8_t)(tmp >> 24);
           dp[1] = (uint8_t)(tmp >> 16);
           dp[2] = (uint8_t)(tmp >> 8);
           dp[3] = (uint8_t)tmp;
         }
         lineSrc += m_nStride;
         lineDst += pDst->m_nStride;
       }
     }
   }
   return 1;
 }