Add GetValidBpc() check in CPDF_DIBSource::GetScanLine

core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.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 "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_render.h"
@@ skipping 1029 matching lines @@
 }
 FX_LPBYTE CPDF_DIBSource::GetBuffer() const
 {
     if (m_pCachedBitmap) {
         return m_pCachedBitmap->GetBuffer();
     }
     return NULL;
 }
 FX_LPCBYTE CPDF_DIBSource::GetScanline(int line) const
 {
-    FX_DWORD src_pitch = (m_Width * m_bpc * m_nComponents + 7) / 8;
+    FX_DWORD bpc = GetValidBpc();
+    if (bpc == 0) {
+        return NULL;
+    }
+    FX_SAFE_DWORD src_pitch = m_Width;
+    src_pitch *= bpc;
+    src_pitch *= m_nComponents;
+    src_pitch += 7;
+    src_pitch /= 8;
+    if (!src_pitch.IsValid())
+        return NULL;
+    FX_DWORD src_pitch_value = src_pitch.ValueOrDie();
     FX_LPCBYTE pSrcLine = NULL;
     if (m_pCachedBitmap) {
         if (line >= m_pCachedBitmap->GetHeight()) {
             line = m_pCachedBitmap->GetHeight() - 1;
         }
         pSrcLine = m_pCachedBitmap->GetScanline(line);
     } else if (m_pDecoder) {
         pSrcLine = m_pDecoder->GetScanline(line);
     } else {
-        if (m_pStreamAcc->GetSize() >= (line + 1) * src_pitch) {
-            pSrcLine = m_pStreamAcc->GetData() + line * src_pitch;
+        if (m_pStreamAcc->GetSize() >= (line + 1) * src_pitch_value) {
+            pSrcLine = m_pStreamAcc->GetData() + line * src_pitch_value;
         }
     }
     if (pSrcLine == NULL) {
         FX_LPBYTE pLineBuf = m_pMaskedLine ? m_pMaskedLine : m_pLineBuf;
         FXSYS_memset8(pLineBuf, 0xff, m_Pitch);
         return pLineBuf;
     }
-    if (m_bpc * m_nComponents == 1) {
+    if (bpc * m_nComponents == 1) {
         if (m_bImageMask && m_bDefaultDecode) {
-            for (FX_DWORD i = 0; i < src_pitch; i ++) {
+            for (FX_DWORD i = 0; i < src_pitch_value; i++) {
                 m_pLineBuf[i] = ~pSrcLine[i];
             }
         } else if (m_bColorKey) {
             FX_DWORD reset_argb, set_argb;
             reset_argb = m_pPalette ? m_pPalette[0] : 0xff000000;
             set_argb = m_pPalette ? m_pPalette[1] : 0xffffffff;
             if (m_pCompData[0].m_ColorKeyMin == 0) {
                 reset_argb = 0;
             }
             if (m_pCompData[0].m_ColorKeyMax == 1) {
                 set_argb = 0;
             }
             set_argb = FXARGB_TODIB(set_argb);
             reset_argb = FXARGB_TODIB(reset_argb);
             FX_DWORD* dest_scan = (FX_DWORD*)m_pMaskedLine;
             for (int col = 0; col < m_Width; col ++) {
                 if (pSrcLine[col / 8] & (1 << (7 - col % 8))) {
                     *dest_scan = set_argb;
                 } else {
                     *dest_scan = reset_argb;
                 }
                 dest_scan ++;
             }
             return m_pMaskedLine;
         } else {
-            FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch);
+            FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
         }
         return m_pLineBuf;
     }
-    if (m_bpc * m_nComponents <= 8) {
-        if (m_bpc == 8) {
-            FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch);
+    if (bpc * m_nComponents <= 8) {
+        if (bpc == 8) {
+            FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
         } else {
             int src_bit_pos = 0;
             for (int col = 0; col < m_Width; col ++) {
                 int color_index = 0;
                 for (FX_DWORD color = 0; color < m_nComponents; color ++) {
-                    int data = _GetBits8(pSrcLine, src_bit_pos, m_bpc);
-                    color_index |= data << (color * m_bpc);
-                    src_bit_pos += m_bpc;
+                    int data = _GetBits8(pSrcLine, src_bit_pos, bpc);
+                    color_index |= data << (color * bpc);
+                    src_bit_pos += bpc;
                 }
                 m_pLineBuf[col] = color_index;
             }
         }
         if (m_bColorKey) {
             FX_LPBYTE pDestPixel = m_pMaskedLine;
             FX_LPCBYTE pSrcPixel = m_pLineBuf;
             for (int col = 0; col < m_Width; col ++) {
                 FX_BYTE index = *pSrcPixel++;
                 if (m_pPalette) {
                     *pDestPixel++ = FXARGB_B(m_pPalette[index]);
                     *pDestPixel++ = FXARGB_G(m_pPalette[index]);
                     *pDestPixel++ = FXARGB_R(m_pPalette[index]);
                 } else {
                     *pDestPixel++ = index;
                     *pDestPixel++ = index;
                     *pDestPixel++ = index;
                 }
                 *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin || index > m_pCompData[0].m_ColorKeyMax) ? 0xff : 0;
                 pDestPixel ++ ;
             }
             return m_pMaskedLine;
         }
         return m_pLineBuf;
     }
     if (m_bColorKey) {
-        if (m_nComponents == 3 && m_bpc == 8) {
+        if (m_nComponents == 3 && bpc == 8) {
             FX_LPBYTE alpha_channel = m_pMaskedLine + 3;
             for (int col = 0; col < m_Width; col ++) {
                 FX_LPCBYTE pPixel = pSrcLine + col * 3;
                 alpha_channel[col * 4] = (pPixel[0] < m_pCompData[0].m_ColorKeyMin ||
                                           pPixel[0] > m_pCompData[0].m_ColorKeyMax ||
                                           pPixel[1] < m_pCompData[1].m_ColorKeyMin || pPixel[1] > m_pCompData[1].m_ColorKeyMax ||
                                           pPixel[2] < m_pCompData[2].m_ColorKeyMin || pPixel[2] > m_pCompData[2].m_ColorKeyMax) ? 0xff : 0;
             }
         } else {
             FXSYS_memset8(m_pMaskedLine, 0xff, m_Pitch);
@@ skipping 377 matching lines @@
     if (!m_bCached) {
         if (m_pBitmap) {
             delete m_pBitmap;
             m_pBitmap = NULL;
         }
         if (m_pMask) {
             delete m_pMask;
         }
     }
 }