Merge to M47: Change |CCodec_ScanlineDecoder::m_Pitch| to FX_DWORD

core/src/fxcodec/codec/fx_codec_flate.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 "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../../../third_party/zlib_v128/zlib.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fxcodec/fx_codec_flate.h"
@@ skipping 540 matching lines @@
     if ((row + 1) * row_size > (int)data_size) {
       row_size = last_row_size;
     }
     TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors,
                              Columns);
   }
   return TRUE;
 }
 
 void TIFF_PredictLine(uint8_t* dest_buf,
-                      int row_size,
+                      FX_DWORD row_size,
                       int BitsPerComponent,
                       int Colors,
                       int Columns) {
   if (BitsPerComponent == 1) {
     int row_bits = FX_MIN(BitsPerComponent * Colors * Columns, row_size * 8);
     int index_pre = 0;
     int col_pre = 0;
     for (int i = 1; i < row_bits; i++) {
       int col = i % 8;
       int index = i / 8;
       if (((dest_buf[index] >> (7 - col)) & 1) ^
           ((dest_buf[index_pre] >> (7 - col_pre)) & 1)) {
         dest_buf[index] |= 1 << (7 - col);
       } else {
         dest_buf[index] &= ~(1 << (7 - col));
       }
       index_pre = index;
       col_pre = col;
     }
     return;
   }
   int BytesPerPixel = BitsPerComponent * Colors / 8;
   if (BitsPerComponent == 16) {
-    for (int i = BytesPerPixel; i < row_size; i += 2) {
+    for (FX_DWORD i = BytesPerPixel; i < row_size; i += 2) {
       FX_WORD pixel =
           (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
       pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
       dest_buf[i] = pixel >> 8;
       dest_buf[i + 1] = (uint8_t)pixel;
     }
   } else {
-    for (int i = BytesPerPixel; i < row_size; i++) {
+    for (FX_DWORD i = BytesPerPixel; i < row_size; i++) {
       dest_buf[i] += dest_buf[i - BytesPerPixel];
     }
   }
 }
 
 FX_BOOL TIFF_Predictor(uint8_t*& data_buf,
                        FX_DWORD& data_size,
                        int Colors,
                        int BitsPerComponent,
                        int Columns) {
@@ skipping 150 matching lines @@
   FX_DWORD GetSrcOffset() override;
 
   void* m_pFlate;
   const uint8_t* m_SrcBuf;
   FX_DWORD m_SrcSize;
   uint8_t* m_pScanline;
   uint8_t* m_pLastLine;
   uint8_t* m_pPredictBuffer;
   uint8_t* m_pPredictRaw;
   int m_Predictor;
-  int m_Colors, m_BitsPerComponent, m_Columns, m_PredictPitch, m_LeftOver;
+  int m_Colors;
+  int m_BitsPerComponent;
+  int m_Columns;
+  FX_DWORD m_PredictPitch;
+  size_t m_LeftOver;
 };
 
 CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() {
   m_pFlate = NULL;
   m_pScanline = NULL;
   m_pLastLine = NULL;
   m_pPredictBuffer = NULL;
   m_pPredictRaw = NULL;
   m_LeftOver = 0;
 }
@@ skipping 16 matching lines @@
                                          int Colors,
                                          int BitsPerComponent,
                                          int Columns) {
   m_SrcBuf = src_buf;
   m_SrcSize = src_size;
   m_OutputWidth = m_OrigWidth = width;
   m_OutputHeight = m_OrigHeight = height;
   m_nComps = nComps;
   m_bpc = bpc;
   m_bColorTransformed = FALSE;
-  m_Pitch = (width * nComps * bpc + 7) / 8;
+  m_Pitch = (static_cast<FX_DWORD>(width) * nComps * bpc + 7) / 8;
   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
   m_Predictor = 0;
   if (predictor) {
     if (predictor >= 10) {
       m_Predictor = 2;
     } else if (predictor == 2) {
       m_Predictor = 1;
     }
     if (m_Predictor) {
       if (BitsPerComponent * Colors * Columns == 0) {
         BitsPerComponent = m_bpc;
         Colors = m_nComps;
         Columns = m_OrigWidth;
       }
       m_Colors = Colors;
       m_BitsPerComponent = BitsPerComponent;
       m_Columns = Columns;
-      m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8;
+      m_PredictPitch =
+          (static_cast<FX_DWORD>(m_BitsPerComponent) * m_Colors * m_Columns +
+           7) /
+          8;
       m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
       m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
       m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
     }
   }
 }
 FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() {
   if (m_pFlate) {
     FPDFAPI_FlateEnd(m_pFlate);
   }
@@ skipping 12 matching lines @@
         FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
         PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine,
                         m_BitsPerComponent, m_Colors, m_Columns);
         FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch);
       } else {
         FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
         TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps,
                          m_OutputWidth);
       }
     } else {
-      int bytes_to_go = m_Pitch;
-      int read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
+      size_t bytes_to_go = m_Pitch;
+      size_t read_leftover =
+          m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
       if (read_leftover) {
         FXSYS_memcpy(m_pScanline,
                      m_pPredictBuffer + m_PredictPitch - m_LeftOver,
                      read_leftover);
         m_LeftOver -= read_leftover;
         bytes_to_go -= read_leftover;
       }
       while (bytes_to_go) {
         if (m_Predictor == 2) {
           FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
           PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine,
                           m_BitsPerComponent, m_Colors, m_Columns);
           FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch);
         } else {
           FPDFAPI_FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch);
           TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent,
                            m_Colors, m_Columns);
         }
-        int read_bytes =
+        size_t read_bytes =
             m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch;
         FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer,
                      read_bytes);
         m_LeftOver += m_PredictPitch - read_bytes;
         bytes_to_go -= read_bytes;
       }
     }
   } else {
     FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
   }
@@ skipping 103 matching lines @@
                                    FX_DWORD src_size,
                                    uint8_t*& dest_buf,
                                    FX_DWORD& dest_size) {
   dest_size = src_size + src_size / 1000 + 12;
   dest_buf = FX_Alloc(uint8_t, dest_size);
   unsigned long temp_size = dest_size;
   FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
   dest_size = (FX_DWORD)temp_size;
   return TRUE;
 }