Use smart pointers for various Jbig2 decoding contexts

core/fxge/dib/fx_dib_main.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/include/fx_dib.h"
 
+#include <algorithm>

[Lei Zhang, 2016/07/19 22:57:26]

C++ headers after C headers.

[Wei Li, 2016/07/19 23:39:41]

Will fix this style in next CL, thanks

 #include <limits.h>
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/include/fx_ge.h"
 
 void CmykDecode(uint32_t cmyk, int& c, int& m, int& y, int& k) {
   c = FXSYS_GetCValue(cmyk);
   m = FXSYS_GetMValue(cmyk);
   y = FXSYS_GetYValue(cmyk);
   k = FXSYS_GetKValue(cmyk);
 }
+
 void ArgbDecode(uint32_t argb, int& a, int& r, int& g, int& b) {
   a = FXARGB_A(argb);
   r = FXARGB_R(argb);
   g = FXARGB_G(argb);
   b = FXARGB_B(argb);
 }
+
 void ArgbDecode(uint32_t argb, int& a, FX_COLORREF& rgb) {
   a = FXARGB_A(argb);
   rgb = FXSYS_RGB(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
 }
+
 uint32_t ArgbEncode(int a, FX_COLORREF rgb) {
   return FXARGB_MAKE(a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb),
                      FXSYS_GetBValue(rgb));
 }
 
-CFX_DIBSource::CFX_DIBSource() {
-  m_bpp = 0;
-  m_AlphaFlag = 0;
-  m_Width = m_Height = 0;
-  m_Pitch = 0;
-  m_pPalette = nullptr;
-  m_pAlphaMask = nullptr;
-}
+CFX_DIBSource::CFX_DIBSource()
+    : m_pAlphaMask(nullptr),
+      m_Width(0),
+      m_Height(0),
+      m_bpp(0),
+      m_AlphaFlag(0),
+      m_Pitch(0) {}
 
 CFX_DIBSource::~CFX_DIBSource() {
-  FX_Free(m_pPalette);
   delete m_pAlphaMask;
 }
 
 uint8_t* CFX_DIBSource::GetBuffer() const {
   return nullptr;
 }
 
 FX_BOOL CFX_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
   return FALSE;
 }
@@ skipping 86 matching lines @@
 }
 
 const uint8_t* CFX_DIBitmap::GetScanline(int line) const {
   return m_pBuffer ? m_pBuffer + line * m_Pitch : nullptr;
 }
 
 void CFX_DIBitmap::TakeOver(CFX_DIBitmap* pSrcBitmap) {
   if (!m_bExtBuf)
     FX_Free(m_pBuffer);
 
-  FX_Free(m_pPalette);
   delete m_pAlphaMask;
   m_pBuffer = pSrcBitmap->m_pBuffer;
-  m_pPalette = pSrcBitmap->m_pPalette;
+  m_pPalette = std::move(pSrcBitmap->m_pPalette);
   m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
   pSrcBitmap->m_pBuffer = nullptr;
-  pSrcBitmap->m_pPalette = nullptr;
   pSrcBitmap->m_pAlphaMask = nullptr;
   m_bpp = pSrcBitmap->m_bpp;
   m_bExtBuf = pSrcBitmap->m_bExtBuf;
   m_AlphaFlag = pSrcBitmap->m_AlphaFlag;
   m_Width = pSrcBitmap->m_Width;
   m_Height = pSrcBitmap->m_Height;
   m_Pitch = pSrcBitmap->m_Pitch;
 }
 
 CFX_DIBitmap* CFX_DIBSource::Clone(const FX_RECT* pClip) const {
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
     if (rect.IsEmpty()) {
       return nullptr;
     }
   }
-  CFX_DIBitmap* pNewBitmap = new CFX_DIBitmap;
-  if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) {
-    delete pNewBitmap;
+  std::unique_ptr<CFX_DIBitmap> pNewBitmap(new CFX_DIBitmap);
+  if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat()))
     return nullptr;
-  }
-  pNewBitmap->CopyPalette(m_pPalette);
+
+  pNewBitmap->CopyPalette(m_pPalette.get());
   pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
   if (GetBPP() == 1 && rect.left % 8 != 0) {
     int left_shift = rect.left % 32;
     int right_shift = 32 - left_shift;
     int dword_count = pNewBitmap->m_Pitch / 4;
     for (int row = rect.top; row < rect.bottom; row++) {
       uint32_t* src_scan = (uint32_t*)GetScanline(row) + rect.left / 32;
       uint32_t* dest_scan = (uint32_t*)pNewBitmap->GetScanline(row - rect.top);
       for (int i = 0; i < dword_count; i++) {
         dest_scan[i] =
             (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
       }
     }
   } else {
     int copy_len = (pNewBitmap->GetWidth() * pNewBitmap->GetBPP() + 7) / 8;
     if (m_Pitch < (uint32_t)copy_len) {
       copy_len = m_Pitch;
     }
     for (int row = rect.top; row < rect.bottom; row++) {
       const uint8_t* src_scan = GetScanline(row) + rect.left * m_bpp / 8;
       uint8_t* dest_scan = (uint8_t*)pNewBitmap->GetScanline(row - rect.top);
       FXSYS_memcpy(dest_scan, src_scan, copy_len);
     }
   }
-  return pNewBitmap;
+  return pNewBitmap.release();
 }
+
 void CFX_DIBSource::BuildPalette() {
   if (m_pPalette) {
     return;
   }
   if (GetBPP() == 1) {
-    m_pPalette = FX_Alloc(uint32_t, 2);
+    m_pPalette.reset(FX_Alloc(uint32_t, 2));
     if (IsCmykImage()) {
-      m_pPalette[0] = 0xff;
-      m_pPalette[1] = 0;
+      m_pPalette.get()[0] = 0xff;
+      m_pPalette.get()[1] = 0;
     } else {
-      m_pPalette[0] = 0xff000000;
-      m_pPalette[1] = 0xffffffff;
+      m_pPalette.get()[0] = 0xff000000;
+      m_pPalette.get()[1] = 0xffffffff;
     }
   } else if (GetBPP() == 8) {
-    m_pPalette = FX_Alloc(uint32_t, 256);
+    m_pPalette.reset(FX_Alloc(uint32_t, 256));
     if (IsCmykImage()) {
       for (int i = 0; i < 256; i++) {
-        m_pPalette[i] = 0xff - i;
+        m_pPalette.get()[i] = 0xff - i;
       }
     } else {
       for (int i = 0; i < 256; i++) {
-        m_pPalette[i] = 0xff000000 | (i * 0x10101);
+        m_pPalette.get()[i] = 0xff000000 | (i * 0x10101);
       }
     }
   }
 }
+
 FX_BOOL CFX_DIBSource::BuildAlphaMask() {
   if (m_pAlphaMask) {
     return TRUE;
   }
   m_pAlphaMask = new CFX_DIBitmap;
   if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
     delete m_pAlphaMask;
     m_pAlphaMask = nullptr;
     return FALSE;
   }
   FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff,
                m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
   return TRUE;
 }
+
 uint32_t CFX_DIBSource::GetPaletteEntry(int index) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (m_pPalette) {
-    return m_pPalette[index];
+    return m_pPalette.get()[index];
   }
   if (IsCmykImage()) {
     if (GetBPP() == 1) {
       return index ? 0 : 0xff;
     }
     return 0xff - index;
   }
   if (GetBPP() == 1) {
     return index ? 0xffffffff : 0xff000000;
   }
   return index * 0x10101 | 0xff000000;
 }
+
 void CFX_DIBSource::SetPaletteEntry(int index, uint32_t color) {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (!m_pPalette) {
     BuildPalette();
   }
-  m_pPalette[index] = color;
+  m_pPalette.get()[index] = color;
 }
+
 int CFX_DIBSource::FindPalette(uint32_t color) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (!m_pPalette) {
     if (IsCmykImage()) {
       if (GetBPP() == 1) {
         return ((uint8_t)color == 0xff) ? 0 : 1;
       }
       return 0xff - (uint8_t)color;
     }
     if (GetBPP() == 1) {
       return ((uint8_t)color == 0xff) ? 1 : 0;
     }
     return (uint8_t)color;
   }
   int palsize = (1 << GetBPP());
   for (int i = 0; i < palsize; i++)
-    if (m_pPalette[i] == color) {
+    if (m_pPalette.get()[i] == color) {
       return i;
     }
   return -1;
 }
+
 void CFX_DIBitmap::Clear(uint32_t color) {
   if (!m_pBuffer) {
     return;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       FXSYS_memset(m_pBuffer, (color & 0xff000000) ? 0xff : 0,
                    m_Pitch * m_Height);
       break;
     case FXDIB_1bppRgb: {
@@ skipping 41 matching lines @@
       }
       for (int row = 1; row < m_Height; row++) {
         FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
       }
       break;
     }
     default:
       break;
   }
 }
+
 void CFX_DIBSource::GetOverlapRect(int& dest_left,
                                    int& dest_top,
                                    int& width,
                                    int& height,
                                    int src_width,
                                    int src_height,
                                    int& src_left,
                                    int& src_top,
                                    const CFX_ClipRgn* pClipRgn) {
   if (width == 0 || height == 0) {
@@ skipping 70 matching lines @@
     }
   } else {
     if (m_pPalette)
       return FALSE;
 
     if (m_bpp == 8)
       dest_format = FXDIB_8bppMask;
 
     uint8_t* dest_buf =
         m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
-    uint32_t* d_plt = nullptr;
+    std::unique_ptr<uint32_t, FxFreeDeleter> d_plt;
     if (!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height,
-                       pSrcBitmap, src_left, src_top, d_plt)) {
+                       pSrcBitmap, src_left, src_top, &d_plt)) {
       return FALSE;
     }
   }
   return TRUE;
 }
 
 FX_BOOL CFX_DIBitmap::TransferMask(int dest_left,
                                    int dest_top,
                                    int width,
                                    int height,
@@ skipping 95 matching lines @@
         for (int col = 0; col < width; col++) {
           FXSYS_memcpy(dest_color_pos, color_p, comps);
           dest_color_pos += comps;
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
   return TRUE;
 }
-void CFX_DIBSource::CopyPalette(const uint32_t* pSrc, uint32_t size) {
+
+void CFX_DIBSource::CopyPalette(const uint32_t* pSrc) {
+  static const uint32_t kPaletteSize = 256;
+
   if (!pSrc || GetBPP() > 8) {
-    FX_Free(m_pPalette);
-    m_pPalette = nullptr;
+    m_pPalette.reset();
   } else {
     uint32_t pal_size = 1 << GetBPP();
-    if (!m_pPalette) {
-      m_pPalette = FX_Alloc(uint32_t, pal_size);
-    }
-    if (pal_size > size) {
-      pal_size = size;
-    }
-    FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(uint32_t));
+    if (!m_pPalette)
+      m_pPalette.reset(FX_Alloc(uint32_t, pal_size));
+    pal_size = std::min(pal_size, kPaletteSize);
+    FXSYS_memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t));
   }
 }
+
 void CFX_DIBSource::GetPalette(uint32_t* pal, int alpha) const {
   ASSERT(GetBPP() <= 8 && !IsCmykImage());
   if (GetBPP() == 1) {
-    pal[0] =
-        ((m_pPalette ? m_pPalette[0] : 0xff000000) & 0xffffff) | (alpha << 24);
-    pal[1] =
-        ((m_pPalette ? m_pPalette[1] : 0xffffffff) & 0xffffff) | (alpha << 24);
+    pal[0] = ((m_pPalette ? m_pPalette.get()[0] : 0xff000000) & 0xffffff) |
+             (alpha << 24);
+    pal[1] = ((m_pPalette ? m_pPalette.get()[1] : 0xffffffff) & 0xffffff) |
+             (alpha << 24);
     return;
   }
   if (m_pPalette) {
     for (int i = 0; i < 256; i++) {
-      pal[i] = (m_pPalette[i] & 0x00ffffff) | (alpha << 24);
+      pal[i] = (m_pPalette.get()[i] & 0x00ffffff) | (alpha << 24);
     }
   } else {
     for (int i = 0; i < 256; i++) {
       pal[i] = (i * 0x10101) | (alpha << 24);
     }
   }
 }
+
 CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const {
   ASSERT(GetFormat() == FXDIB_Argb);
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
     if (rect.IsEmpty()) {
       return nullptr;
     }
   }
   CFX_DIBitmap* pMask = new CFX_DIBitmap;
   if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
     delete pMask;
     return nullptr;
   }
   for (int row = rect.top; row < rect.bottom; row++) {
     const uint8_t* src_scan = GetScanline(row) + rect.left * 4 + 3;
     uint8_t* dest_scan = (uint8_t*)pMask->GetScanline(row - rect.top);
     for (int col = rect.left; col < rect.right; col++) {
       *dest_scan++ = *src_scan;
       src_scan += 4;
     }
   }
   return pMask;
 }
+
 FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
                                      const FX_RECT* pClip) {
   if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
     return FALSE;
   }
   if (pAlphaMask) {
     FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
     if (pClip) {
       rect.Intersect(*pClip);
       if (rect.IsEmpty() || rect.Width() != m_Width ||
           rect.Height() != m_Height) {
         return FALSE;
       }
     } else {
       if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
         return FALSE;
       }
     }
     for (int row = 0; row < m_Height; row++)
       FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),
                    pAlphaMask->GetScanline(row + rect.top) + rect.left,
                    m_pAlphaMask->m_Pitch);
   } else {
     m_pAlphaMask->Clear(0xff000000);
   }
   return TRUE;
 }
+
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
                                   const CFX_DIBSource* pSrcBitmap,
                                   FXDIB_Channel srcChannel) {
   if (!m_pBuffer) {
     return FALSE;
   }
   CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
   CFX_DIBitmap* pDst = this;
   int destOffset, srcOffset;
@@ skipping 123 matching lines @@
       *dest_pos = *src_pos;
       dest_pos += destBytes;
       src_pos += srcBytes;
     }
   }
   if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
     delete pSrcClone;
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value) {
   if (!m_pBuffer) {
     return FALSE;
   }
   int destOffset;
   if (destChannel == FXDIB_Alpha) {
     if (IsAlphaMask()) {
       if (!ConvertFormat(FXDIB_8bppMask)) {
         return FALSE;
       }
@@ skipping 38 matching lines @@
   }
   for (int row = 0; row < m_Height; row++) {
     uint8_t* scan_line = m_pBuffer + row * m_Pitch + destOffset;
     for (int col = 0; col < m_Width; col++) {
       *scan_line = value;
       scan_line += Bpp;
     }
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap) {
   if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(pSrcBitmap->IsAlphaMask());
   if (!pSrcBitmap->IsAlphaMask()) {
     return FALSE;
   }
   if (!IsAlphaMask() && !HasAlpha()) {
     return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
@@ skipping 47 matching lines @@
       }
     } else {
       m_pAlphaMask->MultiplyAlpha(pSrcClone);
     }
   }
   if (pSrcClone != pSrcBitmap) {
     delete pSrcClone;
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
   switch (GetFormat()) {
     case FXDIB_1bppRgb: {
       if (!m_pPalette) {
         return FALSE;
       }
       uint8_t gray[2];
       for (int i = 0; i < 2; i++) {
-        int r = (uint8_t)(m_pPalette[i] >> 16);
-        int g = (uint8_t)(m_pPalette[i] >> 8);
-        int b = (uint8_t)m_pPalette[i];
-        gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
+        int r = static_cast<uint8_t>(m_pPalette.get()[i] >> 16);
+        int g = static_cast<uint8_t>(m_pPalette.get()[i] >> 8);
+        int b = static_cast<uint8_t>(m_pPalette.get()[i]);
+        gray[i] = static_cast<uint8_t>(FXRGB2GRAY(r, g, b));
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
         return FALSE;
       }
       FXSYS_memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
       for (int row = 0; row < m_Height; row++) {
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         uint8_t* dest_pos = (uint8_t*)pMask->GetScanline(row);
         for (int col = 0; col < m_Width; col++) {
           if (src_pos[col / 8] & (1 << (7 - col % 8))) {
             *dest_pos = gray[1];
           }
           dest_pos++;
         }
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     case FXDIB_8bppRgb: {
       if (!m_pPalette) {
         return FALSE;
       }
       uint8_t gray[256];
       for (int i = 0; i < 256; i++) {
-        int r = (uint8_t)(m_pPalette[i] >> 16);
-        int g = (uint8_t)(m_pPalette[i] >> 8);
-        int b = (uint8_t)m_pPalette[i];
-        gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
+        int r = static_cast<uint8_t>(m_pPalette.get()[i] >> 16);
+        int g = static_cast<uint8_t>(m_pPalette.get()[i] >> 8);
+        int b = static_cast<uint8_t>(m_pPalette.get()[i]);
+        gray[i] = static_cast<uint8_t>(FXRGB2GRAY(r, g, b));
       }
       CFX_DIBitmap* pMask = new CFX_DIBitmap;
       if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete pMask;
         return FALSE;
       }
       for (int row = 0; row < m_Height; row++) {
         uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
         uint8_t* src_pos = m_pBuffer + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
@@ skipping 38 matching lines @@
       }
       TakeOver(pMask);
       delete pMask;
       break;
     }
     default:
       return FALSE;
   }
   return TRUE;
 }
+
 FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha) {
   if (!m_pBuffer) {
     return FALSE;
   }
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (!ConvertFormat(FXDIB_8bppMask)) {
         return FALSE;
       }
       MultiplyAlpha(alpha);
@@ skipping 28 matching lines @@
       } else {
         if (!ConvertFormat(FXDIB_Argb)) {
           return FALSE;
         }
         MultiplyAlpha(alpha);
       }
       break;
   }
   return TRUE;
 }
+
 uint32_t CFX_DIBitmap::GetPixel(int x, int y) const {
   if (!m_pBuffer) {
     return 0;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask: {
       if ((*pos) & (1 << (7 - x % 8))) {
         return 0xff000000;
       }
       return 0;
     }
     case FXDIB_1bppRgb: {
       if ((*pos) & (1 << (7 - x % 8))) {
-        return m_pPalette ? m_pPalette[1] : 0xffffffff;
+        return m_pPalette ? m_pPalette.get()[1] : 0xffffffff;
       }
-      return m_pPalette ? m_pPalette[0] : 0xff000000;
+      return m_pPalette ? m_pPalette.get()[0] : 0xff000000;
     }
     case FXDIB_8bppMask:
       return (*pos) << 24;
     case FXDIB_8bppRgb:
-      return m_pPalette ? m_pPalette[*pos] : (0xff000000 | ((*pos) * 0x10101));
+      return m_pPalette ? m_pPalette.get()[*pos]
+                        : (0xff000000 | ((*pos) * 0x10101));
     case FXDIB_Rgb:
     case FXDIB_Rgba:
     case FXDIB_Rgb32:
       return FXARGB_GETDIB(pos) | 0xff000000;
     case FXDIB_Argb:
       return FXARGB_GETDIB(pos);
     default:
       break;
   }
   return 0;
 }
+
 void CFX_DIBitmap::SetPixel(int x, int y, uint32_t color) {
   if (!m_pBuffer) {
     return;
   }
   if (x < 0 || x >= m_Width || y < 0 || y >= m_Height) {
     return;
   }
   uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
   switch (GetFormat()) {
     case FXDIB_1bppMask:
       if (color >> 24) {
         *pos |= 1 << (7 - x % 8);
       } else {
         *pos &= ~(1 << (7 - x % 8));
       }
       break;
     case FXDIB_1bppRgb:
       if (m_pPalette) {
-        if (color == m_pPalette[1]) {
+        if (color == m_pPalette.get()[1]) {
           *pos |= 1 << (7 - x % 8);
         } else {
           *pos &= ~(1 << (7 - x % 8));
         }
       } else {
         if (color == 0xffffffff) {
           *pos |= 1 << (7 - x % 8);
         } else {
           *pos &= ~(1 << (7 - x % 8));
         }
       }
       break;
     case FXDIB_8bppMask:
       *pos = (uint8_t)(color >> 24);
       break;
     case FXDIB_8bppRgb: {
       if (m_pPalette) {
         for (int i = 0; i < 256; i++) {
-          if (m_pPalette[i] == color) {
+          if (m_pPalette.get()[i] == color) {
             *pos = (uint8_t)i;
             return;
           }
         }
         *pos = 0;
       } else {
         *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
       }
       break;
     }
@@ skipping 11 matching lines @@
       pos[2] = FXARGB_R(color);
       break;
     }
     case FXDIB_Argb:
       FXARGB_SETDIB(pos, color);
       break;
     default:
       break;
   }
 }
+
 void CFX_DIBitmap::DownSampleScanline(int line,
                                       uint8_t* dest_scan,
                                       int dest_bpp,
                                       int dest_width,
                                       FX_BOOL bFlipX,
                                       int clip_left,
                                       int clip_width) const {
   if (!m_pBuffer) {
     return;
   }
@@ skipping 14 matching lines @@
       uint32_t dest_x = clip_left + i;
       uint32_t src_x = dest_x * m_Width / dest_width;
       if (bFlipX) {
         src_x = m_Width - src_x - 1;
       }
       src_x %= m_Width;
       int dest_pos = i;
       if (m_pPalette) {
         if (!IsCmykImage()) {
           dest_pos *= 3;
-          FX_ARGB argb = m_pPalette[scanline[src_x]];
+          FX_ARGB argb = m_pPalette.get()[scanline[src_x]];
           dest_scan[dest_pos] = FXARGB_B(argb);
           dest_scan[dest_pos + 1] = FXARGB_G(argb);
           dest_scan[dest_pos + 2] = FXARGB_R(argb);
         } else {
           dest_pos *= 4;
-          FX_CMYK cmyk = m_pPalette[scanline[src_x]];
+          FX_CMYK cmyk = m_pPalette.get()[scanline[src_x]];
           dest_scan[dest_pos] = FXSYS_GetCValue(cmyk);
           dest_scan[dest_pos + 1] = FXSYS_GetMValue(cmyk);
           dest_scan[dest_pos + 2] = FXSYS_GetYValue(cmyk);
           dest_scan[dest_pos + 3] = FXSYS_GetKValue(cmyk);
         }
       } else {
         dest_scan[dest_pos] = scanline[src_x];
       }
     }
   } else {
@@ skipping 61 matching lines @@
     } else if (forecolor == 0 && backcolor == 0xffffff && !m_pPalette) {
       return TRUE;
     }
     if (!m_pPalette) {
       BuildPalette();
     }
     int size = 1 << m_bpp;
     if (isCmykImage) {
       for (int i = 0; i < size; i++) {
         uint8_t b, g, r;
-        AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]),
-                           FXSYS_GetMValue(m_pPalette[i]),
-                           FXSYS_GetYValue(m_pPalette[i]),
-                           FXSYS_GetKValue(m_pPalette[i]), r, g, b);
+        AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette.get()[i]),
+                           FXSYS_GetMValue(m_pPalette.get()[i]),
+                           FXSYS_GetYValue(m_pPalette.get()[i]),
+                           FXSYS_GetKValue(m_pPalette.get()[i]), r, g, b);
         int gray = 255 - FXRGB2GRAY(r, g, b);
-        m_pPalette[i] = CmykEncode(
+        m_pPalette.get()[i] = CmykEncode(
             bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
             by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
       }
     } else {
       for (int i = 0; i < size; i++) {
-        int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]), FXARGB_G(m_pPalette[i]),
-                              FXARGB_B(m_pPalette[i]));
-        m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255,
-                                    bg + (fg - bg) * gray / 255,
-                                    bb + (fb - bb) * gray / 255);
+        int gray = FXRGB2GRAY(FXARGB_R(m_pPalette.get()[i]),
+                              FXARGB_G(m_pPalette.get()[i]),
+                              FXARGB_B(m_pPalette.get()[i]));
+        m_pPalette.get()[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255,
+                                          bg + (fg - bg) * gray / 255,
+                                          bb + (fb - bb) * gray / 255);
       }
     }
     return TRUE;
   }
   if (isCmykImage) {
     if (forecolor == 0xff && backcolor == 0x00) {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* scanline = m_pBuffer + row * m_Pitch;
         for (int col = 0; col < m_Width; col++) {
           uint8_t b, g, r;
@@ skipping 50 matching lines @@
   }
   return TRUE;
 }
 
 CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const {
   CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
   if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
     delete pFlipped;
     return nullptr;
   }
-  pFlipped->CopyPalette(m_pPalette);
+  pFlipped->CopyPalette(m_pPalette.get());
   uint8_t* pDestBuffer = pFlipped->GetBuffer();
   int Bpp = m_bpp / 8;
   for (int row = 0; row < m_Height; row++) {
     const uint8_t* src_scan = GetScanline(row);
     uint8_t* dest_scan =
         pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
     if (!bXFlip) {
       FXSYS_memcpy(dest_scan, src_scan, m_Pitch);
       continue;
     }
@@ skipping 44 matching lines @@
       dest_scan += (m_Width - 1);
       for (int col = 0; col < m_Width; col++) {
         *dest_scan = *src_scan;
         dest_scan--;
         src_scan++;
       }
     }
   }
   return pFlipped;
 }
+
 CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc) {
   m_pBitmap = nullptr;
   if (pSrc->GetBuffer()) {
     m_pBitmap = new CFX_DIBitmap;
     if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(),
                            pSrc->GetFormat(), pSrc->GetBuffer())) {
       delete m_pBitmap;
       m_pBitmap = nullptr;
       return;
     }
     m_pBitmap->CopyPalette(pSrc->GetPalette());
     m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
   } else {
     m_pBitmap = pSrc->Clone();
   }
 }
+
 CFX_DIBExtractor::~CFX_DIBExtractor() {
   delete m_pBitmap;
 }
+
 CFX_FilteredDIB::CFX_FilteredDIB() {
   m_pScanline = nullptr;
   m_pSrc = nullptr;
 }
+
 CFX_FilteredDIB::~CFX_FilteredDIB() {
   if (m_bAutoDropSrc) {
     delete m_pSrc;
   }
   FX_Free(m_pScanline);
 }
+
 void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc) {
   m_pSrc = pSrc;
   m_bAutoDropSrc = bAutoDropSrc;
   m_Width = pSrc->GetWidth();
   m_Height = pSrc->GetHeight();
   FXDIB_Format format = GetDestFormat();
   m_bpp = (uint8_t)format;
   m_AlphaFlag = (uint8_t)(format >> 8);
   m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
-  m_pPalette = GetDestPalette();
+  m_pPalette.reset(GetDestPalette());
   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
 }
+
 const uint8_t* CFX_FilteredDIB::GetScanline(int line) const {
   TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
   return m_pScanline;
 }
+
 void CFX_FilteredDIB::DownSampleScanline(int line,
                                          uint8_t* dest_scan,
                                          int dest_bpp,
                                          int dest_width,
                                          FX_BOOL bFlipX,
                                          int clip_left,
                                          int clip_width) const {
   m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX,
                              clip_left, clip_width);
   TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
 }
+
 CFX_ImageRenderer::CFX_ImageRenderer() {
   m_Status = 0;
   m_pTransformer = nullptr;
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
+
 CFX_ImageRenderer::~CFX_ImageRenderer() {
   delete m_pTransformer;
 }
 
 FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice,
                                  const CFX_ClipRgn* pClipRgn,
                                  const CFX_DIBSource* pSource,
                                  int bitmap_alpha,
                                  uint32_t mask_color,
                                  const CFX_Matrix* pMatrix,
@@ skipping 137 matching lines @@
           ? const_cast<uint8_t*>(m_pBitmap->m_pAlphaMask->GetScanline(line))
           : nullptr;
   if (dest_buf)
     FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
 
   if (dest_alpha_buf) {
     FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha,
                  m_pBitmap->m_pAlphaMask->GetPitch());
   }
 }
+
 FX_BOOL CFX_BitmapStorer::SetInfo(int width,
                                   int height,
                                   FXDIB_Format src_format,
                                   uint32_t* pSrcPalette) {
   m_pBitmap.reset(new CFX_DIBitmap);
   if (!m_pBitmap->Create(width, height, src_format)) {
     m_pBitmap.reset();
     return FALSE;
   }
   if (pSrcPalette)
     m_pBitmap->CopyPalette(pSrcPalette);
   return TRUE;
 }