summaryrefslogtreecommitdiff
path: root/core/fxge
diff options
context:
space:
mode:
Diffstat (limited to 'core/fxge')
-rw-r--r--core/fxge/dib/cfx_dibextractor.cpp27
-rw-r--r--core/fxge/dib/cfx_dibextractor.h26
-rw-r--r--core/fxge/dib/cfx_dibitmap.cpp1469
-rw-r--r--core/fxge/dib/fx_dib_composite.cpp353
-rw-r--r--core/fxge/dib/fx_dib_convert.cpp84
-rw-r--r--core/fxge/dib/fx_dib_main.cpp1048
-rw-r--r--core/fxge/fx_dib.h11
-rw-r--r--core/fxge/win32/cfx_psrenderer.cpp1
-rw-r--r--core/fxge/win32/fx_win32_device.cpp1
-rw-r--r--core/fxge/win32/fx_win32_print.cpp1
10 files changed, 1529 insertions, 1492 deletions
diff --git a/core/fxge/dib/cfx_dibextractor.cpp b/core/fxge/dib/cfx_dibextractor.cpp
new file mode 100644
index 0000000000..8de69e2e3b
--- /dev/null
+++ b/core/fxge/dib/cfx_dibextractor.cpp
@@ -0,0 +1,27 @@
+// Copyright 2017 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/dib/cfx_dibextractor.h"
+
+#include "core/fxge/dib/cfx_dibsource.h"
+
+CFX_DIBExtractor::CFX_DIBExtractor(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
+ if (!pSrc->GetBuffer()) {
+ m_pBitmap = pSrc->Clone();
+ return;
+ }
+ CFX_RetainPtr<CFX_DIBSource> pOldSrc(pSrc);
+ m_pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
+ if (!m_pBitmap->Create(pOldSrc->GetWidth(), pOldSrc->GetHeight(),
+ pOldSrc->GetFormat(), pOldSrc->GetBuffer())) {
+ m_pBitmap.Reset();
+ return;
+ }
+ m_pBitmap->SetPalette(pOldSrc->GetPalette());
+ m_pBitmap->SetAlphaMask(pOldSrc->m_pAlphaMask);
+}
+
+CFX_DIBExtractor::~CFX_DIBExtractor() {}
diff --git a/core/fxge/dib/cfx_dibextractor.h b/core/fxge/dib/cfx_dibextractor.h
new file mode 100644
index 0000000000..25d80ecb94
--- /dev/null
+++ b/core/fxge/dib/cfx_dibextractor.h
@@ -0,0 +1,26 @@
+// Copyright 2017 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
+
+#ifndef CORE_FXGE_DIB_CFX_DIBEXTRACTOR_H_
+#define CORE_FXGE_DIB_CFX_DIBEXTRACTOR_H_
+
+#include "core/fxcrt/cfx_retain_ptr.h"
+#include "core/fxge/dib/cfx_dibitmap.h"
+
+class CFX_DIBSource;
+
+class CFX_DIBExtractor {
+ public:
+ explicit CFX_DIBExtractor(const CFX_RetainPtr<CFX_DIBSource>& pSrc);
+ ~CFX_DIBExtractor();
+
+ CFX_RetainPtr<CFX_DIBitmap> GetBitmap() { return m_pBitmap; }
+
+ private:
+ CFX_RetainPtr<CFX_DIBitmap> m_pBitmap;
+};
+
+#endif // CORE_FXGE_DIB_CFX_DIBEXTRACTOR_H_
diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp
new file mode 100644
index 0000000000..0adc088b53
--- /dev/null
+++ b/core/fxge/dib/cfx_dibitmap.cpp
@@ -0,0 +1,1469 @@
+// Copyright 2017 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/dib/cfx_dibitmap.h"
+
+#include <limits>
+#include <memory>
+#include <utility>
+
+#include "core/fxcodec/fx_codec.h"
+#include "core/fxge/cfx_gemodule.h"
+#include "core/fxge/dib/dib_int.h"
+#include "core/fxge/ge/cfx_cliprgn.h"
+#include "third_party/base/ptr_util.h"
+
+#define MAX_OOM_LIMIT 12000000
+
+CFX_DIBitmap::CFX_DIBitmap() {
+ m_bExtBuf = false;
+ m_pBuffer = nullptr;
+ m_pPalette = nullptr;
+#ifdef _SKIA_SUPPORT_PATHS_
+ m_nFormat = Format::kCleared;
+#endif
+}
+
+bool CFX_DIBitmap::Create(int width,
+ int height,
+ FXDIB_Format format,
+ uint8_t* pBuffer,
+ int pitch) {
+ m_pBuffer = nullptr;
+ m_bpp = static_cast<uint8_t>(format);
+ m_AlphaFlag = static_cast<uint8_t>(format >> 8);
+ m_Width = m_Height = m_Pitch = 0;
+ if (width <= 0 || height <= 0 || pitch < 0)
+ return false;
+
+ if ((INT_MAX - 31) / width < (format & 0xff))
+ return false;
+
+ if (!pitch)
+ pitch = (width * (format & 0xff) + 31) / 32 * 4;
+
+ if ((1 << 30) / pitch < height)
+ return false;
+
+ if (pBuffer) {
+ m_pBuffer = pBuffer;
+ m_bExtBuf = true;
+ } else {
+ int size = pitch * height + 4;
+ int oomlimit = MAX_OOM_LIMIT;
+ if (oomlimit >= 0 && size >= oomlimit) {
+ m_pBuffer = FX_TryAlloc(uint8_t, size);
+ if (!m_pBuffer)
+ return false;
+ } else {
+ m_pBuffer = FX_Alloc(uint8_t, size);
+ }
+ }
+ m_Width = width;
+ m_Height = height;
+ m_Pitch = pitch;
+ if (!HasAlpha() || format == FXDIB_Argb)
+ return true;
+
+ if (BuildAlphaMask())
+ return true;
+
+ if (m_bExtBuf)
+ return true;
+
+ FX_Free(m_pBuffer);
+ m_pBuffer = nullptr;
+ m_Width = m_Height = m_Pitch = 0;
+ return false;
+}
+
+bool CFX_DIBitmap::Copy(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
+ if (m_pBuffer)
+ return false;
+
+ if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat()))
+ return false;
+
+ SetPalette(pSrc->GetPalette());
+ SetAlphaMask(pSrc->m_pAlphaMask);
+ for (int row = 0; row < pSrc->GetHeight(); row++)
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
+ return true;
+}
+
+CFX_DIBitmap::~CFX_DIBitmap() {
+ if (!m_bExtBuf)
+ FX_Free(m_pBuffer);
+}
+
+uint8_t* CFX_DIBitmap::GetBuffer() const {
+ return m_pBuffer;
+}
+
+const uint8_t* CFX_DIBitmap::GetScanline(int line) const {
+ return m_pBuffer ? m_pBuffer + line * m_Pitch : nullptr;
+}
+
+void CFX_DIBitmap::TakeOver(CFX_RetainPtr<CFX_DIBitmap>&& pSrcBitmap) {
+ if (!m_bExtBuf)
+ FX_Free(m_pBuffer);
+
+ m_pBuffer = pSrcBitmap->m_pBuffer;
+ m_pPalette = std::move(pSrcBitmap->m_pPalette);
+ m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
+ pSrcBitmap->m_pBuffer = 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;
+}
+
+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: {
+ int index = FindPalette(color);
+ FXSYS_memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
+ break;
+ }
+ case FXDIB_8bppMask:
+ FXSYS_memset(m_pBuffer, color >> 24, m_Pitch * m_Height);
+ break;
+ case FXDIB_8bppRgb: {
+ int index = FindPalette(color);
+ FXSYS_memset(m_pBuffer, index, m_Pitch * m_Height);
+ break;
+ }
+ case FXDIB_Rgb:
+ case FXDIB_Rgba: {
+ int a, r, g, b;
+ ArgbDecode(color, a, r, g, b);
+ if (r == g && g == b) {
+ FXSYS_memset(m_pBuffer, r, m_Pitch * m_Height);
+ } else {
+ int byte_pos = 0;
+ for (int col = 0; col < m_Width; col++) {
+ m_pBuffer[byte_pos++] = b;
+ m_pBuffer[byte_pos++] = g;
+ m_pBuffer[byte_pos++] = r;
+ }
+ for (int row = 1; row < m_Height; row++) {
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+ }
+ }
+ break;
+ }
+ case FXDIB_Rgb32:
+ case FXDIB_Argb: {
+ color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
+#ifdef _SKIA_SUPPORT_
+ if (FXDIB_Rgb32 == GetFormat() && !IsCmykImage()) {
+ color |= 0xFF000000;
+ }
+#endif
+ for (int i = 0; i < m_Width; i++) {
+ ((uint32_t*)m_pBuffer)[i] = color;
+ }
+ for (int row = 1; row < m_Height; row++) {
+ FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+bool CFX_DIBitmap::TransferBitmap(
+ int dest_left,
+ int dest_top,
+ int width,
+ int height,
+ const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
+ int src_left,
+ int src_top) {
+ if (!m_pBuffer)
+ return false;
+
+ GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
+ pSrcBitmap->GetHeight(), src_left, src_top, nullptr);
+ if (width == 0 || height == 0)
+ return true;
+
+ FXDIB_Format dest_format = GetFormat();
+ FXDIB_Format src_format = pSrcBitmap->GetFormat();
+ if (dest_format == src_format) {
+ if (GetBPP() == 1) {
+ for (int row = 0; row < height; row++) {
+ uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
+ const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
+ for (int col = 0; col < width; col++) {
+ if (src_scan[(src_left + col) / 8] &
+ (1 << (7 - (src_left + col) % 8))) {
+ dest_scan[(dest_left + col) / 8] |= 1
+ << (7 - (dest_left + col) % 8);
+ } else {
+ dest_scan[(dest_left + col) / 8] &=
+ ~(1 << (7 - (dest_left + col) % 8));
+ }
+ }
+ }
+ } else {
+ int Bpp = GetBPP() / 8;
+ for (int row = 0; row < height; row++) {
+ uint8_t* dest_scan =
+ m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
+ const uint8_t* src_scan =
+ pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
+ FXSYS_memcpy(dest_scan, src_scan, width * Bpp);
+ }
+ }
+ } 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;
+ 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)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::TransferMask(int dest_left,
+ int dest_top,
+ int width,
+ int height,
+ const CFX_RetainPtr<CFX_DIBSource>& pMask,
+ uint32_t color,
+ int src_left,
+ int src_top,
+ int alpha_flag,
+ void* pIccTransform) {
+ if (!m_pBuffer) {
+ return false;
+ }
+ ASSERT(HasAlpha() && (m_bpp >= 24));
+ ASSERT(pMask->IsAlphaMask());
+ if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
+ return false;
+ }
+ GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
+ pMask->GetHeight(), src_left, src_top, nullptr);
+ if (width == 0 || height == 0) {
+ return true;
+ }
+ int src_bpp = pMask->GetBPP();
+ int alpha;
+ uint32_t dst_color;
+ if (alpha_flag >> 8) {
+ alpha = alpha_flag & 0xff;
+ dst_color = FXCMYK_TODIB(color);
+ } else {
+ alpha = FXARGB_A(color);
+ dst_color = FXARGB_TODIB(color);
+ }
+ uint8_t* color_p = (uint8_t*)&dst_color;
+ if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
+ CCodec_IccModule* pIccModule =
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+ pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
+ } else {
+ if (alpha_flag >> 8 && !IsCmykImage()) {
+ AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
+ FXSYS_GetYValue(color), FXSYS_GetKValue(color),
+ color_p[2], color_p[1], color_p[0]);
+ } else if (!(alpha_flag >> 8) && IsCmykImage()) {
+ return false;
+ }
+ }
+ if (!IsCmykImage()) {
+ color_p[3] = (uint8_t)alpha;
+ }
+ if (GetFormat() == FXDIB_Argb) {
+ for (int row = 0; row < height; row++) {
+ uint32_t* dest_pos =
+ (uint32_t*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
+ const uint8_t* src_scan = pMask->GetScanline(src_top + row);
+ if (src_bpp == 1) {
+ for (int col = 0; col < width; col++) {
+ int src_bitpos = src_left + col;
+ if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
+ *dest_pos = dst_color;
+ } else {
+ *dest_pos = 0;
+ }
+ dest_pos++;
+ }
+ } else {
+ src_scan += src_left;
+ dst_color = FXARGB_TODIB(dst_color);
+ dst_color &= 0xffffff;
+ for (int col = 0; col < width; col++) {
+ FXARGB_SETDIB(dest_pos++,
+ dst_color | ((alpha * (*src_scan++) / 255) << 24));
+ }
+ }
+ }
+ } else {
+ int comps = m_bpp / 8;
+ for (int row = 0; row < height; row++) {
+ uint8_t* dest_color_pos =
+ m_pBuffer + (dest_top + row) * m_Pitch + dest_left * comps;
+ uint8_t* dest_alpha_pos =
+ (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left;
+ const uint8_t* src_scan = pMask->GetScanline(src_top + row);
+ if (src_bpp == 1) {
+ for (int col = 0; col < width; col++) {
+ int src_bitpos = src_left + col;
+ if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
+ FXSYS_memcpy(dest_color_pos, color_p, comps);
+ *dest_alpha_pos = 0xff;
+ } else {
+ FXSYS_memset(dest_color_pos, 0, comps);
+ *dest_alpha_pos = 0;
+ }
+ dest_color_pos += comps;
+ dest_alpha_pos++;
+ }
+ } else {
+ src_scan += src_left;
+ 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;
+}
+
+const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
+ const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
+ FXDIB_Channel srcChannel) {
+ if (!m_pBuffer)
+ return false;
+
+ CFX_RetainPtr<CFX_DIBSource> pSrcClone = pSrcBitmap;
+ int srcOffset;
+ if (srcChannel == FXDIB_Alpha) {
+ if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask())
+ return false;
+
+ if (pSrcBitmap->GetBPP() == 1) {
+ pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
+ if (!pSrcClone)
+ return false;
+ }
+ srcOffset = pSrcBitmap->GetFormat() == FXDIB_Argb ? 3 : 0;
+ } else {
+ if (pSrcBitmap->IsAlphaMask())
+ return false;
+
+ if (pSrcBitmap->GetBPP() < 24) {
+ if (pSrcBitmap->IsCmykImage()) {
+ pSrcClone = pSrcBitmap->CloneConvert(static_cast<FXDIB_Format>(
+ (pSrcBitmap->GetFormat() & 0xff00) | 0x20));
+ } else {
+ pSrcClone = pSrcBitmap->CloneConvert(static_cast<FXDIB_Format>(
+ (pSrcBitmap->GetFormat() & 0xff00) | 0x18));
+ }
+ if (!pSrcClone)
+ return false;
+ }
+ srcOffset = g_ChannelOffset[srcChannel];
+ }
+ int destOffset = 0;
+ if (destChannel == FXDIB_Alpha) {
+ if (IsAlphaMask()) {
+ if (!ConvertFormat(FXDIB_8bppMask))
+ return false;
+ } else {
+ if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
+ return false;
+
+ if (GetFormat() == FXDIB_Argb)
+ destOffset = 3;
+ }
+ } else {
+ if (IsAlphaMask())
+ return false;
+
+ if (GetBPP() < 24) {
+ if (HasAlpha()) {
+ if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
+ return false;
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+ } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
+#else
+ } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
+#endif
+ return false;
+ }
+ }
+ destOffset = g_ChannelOffset[destChannel];
+ }
+ if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
+ CFX_RetainPtr<CFX_DIBSource> pAlphaMask = pSrcClone->m_pAlphaMask;
+ if (pSrcClone->GetWidth() != m_Width ||
+ pSrcClone->GetHeight() != m_Height) {
+ if (pAlphaMask) {
+ pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
+ if (!pAlphaMask)
+ return false;
+ }
+ }
+ pSrcClone = std::move(pAlphaMask);
+ srcOffset = 0;
+ } else if (pSrcClone->GetWidth() != m_Width ||
+ pSrcClone->GetHeight() != m_Height) {
+ CFX_RetainPtr<CFX_DIBitmap> pSrcMatched =
+ pSrcClone->StretchTo(m_Width, m_Height);
+ if (!pSrcMatched)
+ return false;
+
+ pSrcClone = std::move(pSrcMatched);
+ }
+ CFX_RetainPtr<CFX_DIBitmap> pDst(this);
+ if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
+ pDst = m_pAlphaMask;
+ destOffset = 0;
+ }
+ int srcBytes = pSrcClone->GetBPP() / 8;
+ int destBytes = pDst->GetBPP() / 8;
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* dest_pos = (uint8_t*)pDst->GetScanline(row) + destOffset;
+ const uint8_t* src_pos = pSrcClone->GetScanline(row) + srcOffset;
+ for (int col = 0; col < m_Width; col++) {
+ *dest_pos = *src_pos;
+ dest_pos += destBytes;
+ src_pos += srcBytes;
+ }
+ }
+ return true;
+}
+
+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;
+ }
+ destOffset = 0;
+ } else {
+ destOffset = 0;
+ if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+ return false;
+ }
+ if (GetFormat() == FXDIB_Argb) {
+ destOffset = 3;
+ }
+ }
+ } else {
+ if (IsAlphaMask()) {
+ return false;
+ }
+ if (GetBPP() < 24) {
+ if (HasAlpha()) {
+ if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
+ return false;
+ }
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+ } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
+#else
+ } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
+#endif
+ return false;
+ }
+ }
+ destOffset = g_ChannelOffset[destChannel];
+ }
+ int Bpp = GetBPP() / 8;
+ if (Bpp == 1) {
+ FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
+ return true;
+ }
+ if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
+ FXSYS_memset(m_pAlphaMask->GetBuffer(), value,
+ m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
+ return true;
+ }
+ 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;
+}
+
+bool CFX_DIBitmap::MultiplyAlpha(
+ const CFX_RetainPtr<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);
+
+ CFX_RetainPtr<CFX_DIBitmap> pSrcClone = pSrcBitmap.As<CFX_DIBitmap>();
+ if (pSrcBitmap->GetWidth() != m_Width ||
+ pSrcBitmap->GetHeight() != m_Height) {
+ pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
+ if (!pSrcClone)
+ return false;
+ }
+ if (IsAlphaMask()) {
+ if (!ConvertFormat(FXDIB_8bppMask))
+ return false;
+
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* dest_scan = m_pBuffer + m_Pitch * row;
+ uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
+ if (pSrcClone->GetBPP() == 1) {
+ for (int col = 0; col < m_Width; col++) {
+ if (!((1 << (7 - col % 8)) & src_scan[col / 8]))
+ dest_scan[col] = 0;
+ }
+ } else {
+ for (int col = 0; col < m_Width; col++) {
+ *dest_scan = (*dest_scan) * src_scan[col] / 255;
+ dest_scan++;
+ }
+ }
+ }
+ } else {
+ if (GetFormat() == FXDIB_Argb) {
+ if (pSrcClone->GetBPP() == 1)
+ return false;
+
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* dest_scan = m_pBuffer + m_Pitch * row + 3;
+ uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
+ for (int col = 0; col < m_Width; col++) {
+ *dest_scan = (*dest_scan) * src_scan[col] / 255;
+ dest_scan += 4;
+ }
+ }
+ } else {
+ m_pAlphaMask->MultiplyAlpha(pSrcClone);
+ }
+ }
+ return true;
+}
+
+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 = 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));
+ }
+ auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
+ if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
+ 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(std::move(pMask));
+ break;
+ }
+ case FXDIB_8bppRgb: {
+ if (!m_pPalette)
+ return false;
+
+ uint8_t gray[256];
+ for (int i = 0; i < 256; i++) {
+ 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));
+ }
+ auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
+ if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
+ 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++) {
+ *dest_pos++ = gray[*src_pos++];
+ }
+ }
+ TakeOver(std::move(pMask));
+ break;
+ }
+ case FXDIB_Rgb: {
+ auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
+ if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
+ return false;
+
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* src_pos = m_pBuffer + row * m_Pitch;
+ uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
+ for (int col = 0; col < m_Width; col++) {
+ *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
+ src_pos += 3;
+ }
+ }
+ TakeOver(std::move(pMask));
+ break;
+ }
+ case FXDIB_Rgb32: {
+ auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
+ if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
+ return false;
+
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* src_pos = m_pBuffer + row * m_Pitch;
+ uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
+ for (int col = 0; col < m_Width; col++) {
+ *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
+ src_pos += 4;
+ }
+ }
+ TakeOver(std::move(pMask));
+ break;
+ }
+ default:
+ return false;
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::MultiplyAlpha(int alpha) {
+ if (!m_pBuffer) {
+ return false;
+ }
+ switch (GetFormat()) {
+ case FXDIB_1bppMask:
+ if (!ConvertFormat(FXDIB_8bppMask)) {
+ return false;
+ }
+ MultiplyAlpha(alpha);
+ break;
+ case FXDIB_8bppMask: {
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* scan_line = m_pBuffer + row * m_Pitch;
+ for (int col = 0; col < m_Width; col++) {
+ scan_line[col] = scan_line[col] * alpha / 255;
+ }
+ }
+ break;
+ }
+ case FXDIB_Argb: {
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* scan_line = m_pBuffer + row * m_Pitch + 3;
+ for (int col = 0; col < m_Width; col++) {
+ *scan_line = (*scan_line) * alpha / 255;
+ scan_line += 4;
+ }
+ }
+ break;
+ }
+ default:
+ if (HasAlpha()) {
+ m_pAlphaMask->MultiplyAlpha(alpha);
+ } else if (IsCmykImage()) {
+ if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
+ return false;
+ }
+ m_pAlphaMask->MultiplyAlpha(alpha);
+ } 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.get()[1] : 0xffffffff;
+ }
+ return m_pPalette ? m_pPalette.get()[0] : 0xff000000;
+ }
+ case FXDIB_8bppMask:
+ return (*pos) << 24;
+ case FXDIB_8bppRgb:
+ 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.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.get()[i] == color) {
+ *pos = (uint8_t)i;
+ return;
+ }
+ }
+ *pos = 0;
+ } else {
+ *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
+ }
+ break;
+ }
+ case FXDIB_Rgb:
+ case FXDIB_Rgb32: {
+ int alpha = FXARGB_A(color);
+ pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
+ pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
+ pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
+ break;
+ }
+ case FXDIB_Rgba: {
+ pos[0] = FXARGB_B(color);
+ pos[1] = FXARGB_G(color);
+ 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,
+ bool bFlipX,
+ int clip_left,
+ int clip_width) const {
+ if (!m_pBuffer) {
+ return;
+ }
+ int src_Bpp = m_bpp / 8;
+ uint8_t* scanline = m_pBuffer + line * m_Pitch;
+ if (src_Bpp == 0) {
+ for (int i = 0; i < clip_width; i++) {
+ 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;
+ dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
+ }
+ } else if (src_Bpp == 1) {
+ for (int i = 0; i < clip_width; i++) {
+ 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.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.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 {
+ for (int i = 0; i < clip_width; i++) {
+ uint32_t dest_x = clip_left + i;
+ uint32_t src_x =
+ bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp
+ : (dest_x * m_Width / dest_width) * src_Bpp;
+ src_x %= m_Width * src_Bpp;
+ int dest_pos = i * src_Bpp;
+ for (int b = 0; b < src_Bpp; b++) {
+ dest_scan[dest_pos + b] = scanline[src_x + b];
+ }
+ }
+ }
+}
+
+// TODO(weili): Split this function into two for handling CMYK and RGB
+// colors separately.
+bool CFX_DIBitmap::ConvertColorScale(uint32_t forecolor, uint32_t backcolor) {
+ ASSERT(!IsAlphaMask());
+ if (!m_pBuffer || IsAlphaMask()) {
+ return false;
+ }
+ // Values used for CMYK colors.
+ int fc = 0;
+ int fm = 0;
+ int fy = 0;
+ int fk = 0;
+ int bc = 0;
+ int bm = 0;
+ int by = 0;
+ int bk = 0;
+ // Values used for RGB colors.
+ int fr = 0;
+ int fg = 0;
+ int fb = 0;
+ int br = 0;
+ int bg = 0;
+ int bb = 0;
+ bool isCmykImage = IsCmykImage();
+ if (isCmykImage) {
+ fc = FXSYS_GetCValue(forecolor);
+ fm = FXSYS_GetMValue(forecolor);
+ fy = FXSYS_GetYValue(forecolor);
+ fk = FXSYS_GetKValue(forecolor);
+ bc = FXSYS_GetCValue(backcolor);
+ bm = FXSYS_GetMValue(backcolor);
+ by = FXSYS_GetYValue(backcolor);
+ bk = FXSYS_GetKValue(backcolor);
+ } else {
+ fr = FXSYS_GetRValue(forecolor);
+ fg = FXSYS_GetGValue(forecolor);
+ fb = FXSYS_GetBValue(forecolor);
+ br = FXSYS_GetRValue(backcolor);
+ bg = FXSYS_GetGValue(backcolor);
+ bb = FXSYS_GetBValue(backcolor);
+ }
+ if (m_bpp <= 8) {
+ if (isCmykImage) {
+ if (forecolor == 0xff && backcolor == 0 && !m_pPalette) {
+ return true;
+ }
+ } 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.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.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.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;
+ AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
+ r, g, b);
+ *scanline++ = 0;
+ *scanline++ = 0;
+ *scanline++ = 0;
+ *scanline++ = 255 - FXRGB2GRAY(r, g, b);
+ }
+ }
+ return true;
+ }
+ } else if (forecolor == 0 && backcolor == 0xffffff) {
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* scanline = m_pBuffer + row * m_Pitch;
+ int gap = m_bpp / 8 - 2;
+ for (int col = 0; col < m_Width; col++) {
+ int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
+ *scanline++ = gray;
+ *scanline++ = gray;
+ *scanline = gray;
+ scanline += gap;
+ }
+ }
+ return true;
+ }
+ if (isCmykImage) {
+ 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;
+ AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
+ r, g, b);
+ int gray = 255 - FXRGB2GRAY(r, g, b);
+ *scanline++ = bc + (fc - bc) * gray / 255;
+ *scanline++ = bm + (fm - bm) * gray / 255;
+ *scanline++ = by + (fy - by) * gray / 255;
+ *scanline++ = bk + (fk - bk) * gray / 255;
+ }
+ }
+ } else {
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* scanline = m_pBuffer + row * m_Pitch;
+ int gap = m_bpp / 8 - 2;
+ for (int col = 0; col < m_Width; col++) {
+ int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
+ *scanline++ = bb + (fb - bb) * gray / 255;
+ *scanline++ = bg + (fg - bg) * gray / 255;
+ *scanline = br + (fr - br) * gray / 255;
+ scanline += gap;
+ }
+ }
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::CompositeBitmap(
+ int dest_left,
+ int dest_top,
+ int width,
+ int height,
+ const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
+ int src_left,
+ int src_top,
+ int blend_type,
+ const CFX_ClipRgn* pClipRgn,
+ bool bRgbByteOrder,
+ void* pIccTransform) {
+ 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) {
+ return true;
+ }
+ CFX_RetainPtr<CFX_DIBitmap> pClipMask;
+ FX_RECT clip_box;
+ if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
+ ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
+ pClipMask = pClipRgn->GetMask();
+ clip_box = pClipRgn->GetBox();
+ }
+ CFX_ScanlineCompositor compositor;
+ if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width,
+ pSrcBitmap->GetPalette(), 0, blend_type,
+ pClipMask != nullptr, bRgbByteOrder, 0, pIccTransform)) {
+ return false;
+ }
+ int dest_Bpp = m_bpp / 8;
+ int src_Bpp = pSrcBitmap->GetBPP() / 8;
+ bool bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
+ CFX_RetainPtr<CFX_DIBitmap> pSrcAlphaMask = pSrcBitmap->m_pAlphaMask;
+ for (int row = 0; row < height; row++) {
+ uint8_t* dest_scan =
+ m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
+ const uint8_t* src_scan =
+ pSrcBitmap->GetScanline(src_top + row) + src_left * src_Bpp;
+ const uint8_t* src_scan_extra_alpha =
+ pSrcAlphaMask ? pSrcAlphaMask->GetScanline(src_top + row) + src_left
+ : nullptr;
+ uint8_t* dst_scan_extra_alpha =
+ m_pAlphaMask
+ ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
+ : nullptr;
+ const uint8_t* clip_scan = nullptr;
+ if (pClipMask) {
+ clip_scan = pClipMask->m_pBuffer +
+ (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
+ (dest_left - clip_box.left);
+ }
+ if (bRgb) {
+ compositor.CompositeRgbBitmapLine(dest_scan, src_scan, width, clip_scan,
+ src_scan_extra_alpha,
+ dst_scan_extra_alpha);
+ } else {
+ compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width,
+ clip_scan, src_scan_extra_alpha,
+ dst_scan_extra_alpha);
+ }
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::CompositeMask(int dest_left,
+ int dest_top,
+ int width,
+ int height,
+ const CFX_RetainPtr<CFX_DIBSource>& pMask,
+ uint32_t color,
+ int src_left,
+ int src_top,
+ int blend_type,
+ const CFX_ClipRgn* pClipRgn,
+ bool bRgbByteOrder,
+ int alpha_flag,
+ void* pIccTransform) {
+ 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) {
+ return true;
+ }
+ int src_alpha =
+ (uint8_t)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
+ if (src_alpha == 0) {
+ return true;
+ }
+ CFX_RetainPtr<CFX_DIBitmap> pClipMask;
+ FX_RECT clip_box;
+ if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
+ ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
+ pClipMask = pClipRgn->GetMask();
+ clip_box = pClipRgn->GetBox();
+ }
+ int src_bpp = pMask->GetBPP();
+ int Bpp = GetBPP() / 8;
+ CFX_ScanlineCompositor compositor;
+ if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, nullptr, color,
+ blend_type, pClipMask != nullptr, bRgbByteOrder,
+ alpha_flag, pIccTransform)) {
+ return false;
+ }
+ for (int row = 0; row < height; row++) {
+ uint8_t* dest_scan =
+ m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
+ const uint8_t* src_scan = pMask->GetScanline(src_top + row);
+ uint8_t* dst_scan_extra_alpha =
+ m_pAlphaMask
+ ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
+ : nullptr;
+ const uint8_t* clip_scan = nullptr;
+ if (pClipMask) {
+ clip_scan = pClipMask->m_pBuffer +
+ (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
+ (dest_left - clip_box.left);
+ }
+ if (src_bpp == 1) {
+ compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width,
+ clip_scan, dst_scan_extra_alpha);
+ } else {
+ compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width,
+ clip_scan, dst_scan_extra_alpha);
+ }
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::CompositeRect(int left,
+ int top,
+ int width,
+ int height,
+ uint32_t color,
+ int alpha_flag,
+ void* pIccTransform) {
+ 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;
+ }
+ width = rect.Width();
+ uint32_t dst_color;
+ if (alpha_flag >> 8) {
+ dst_color = FXCMYK_TODIB(color);
+ } else {
+ dst_color = FXARGB_TODIB(color);
+ }
+ uint8_t* color_p = (uint8_t*)&dst_color;
+ if (m_bpp == 8) {
+ uint8_t gray = 255;
+ if (!IsAlphaMask()) {
+ if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
+ CCodec_IccModule* pIccModule =
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+ pIccModule->TranslateScanline(pIccTransform, &gray, color_p, 1);
+ } else {
+ if (alpha_flag >> 8) {
+ uint8_t r, g, b;
+ AdobeCMYK_to_sRGB1(color_p[0], color_p[1], color_p[2], color_p[3], r,
+ g, b);
+ gray = FXRGB2GRAY(r, g, b);
+ } else {
+ gray = (uint8_t)FXRGB2GRAY((int)color_p[2], color_p[1], color_p[0]);
+ }
+ }
+ if (IsCmykImage()) {
+ gray = ~gray;
+ }
+ }
+ for (int row = rect.top; row < rect.bottom; row++) {
+ uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left;
+ if (src_alpha == 255) {
+ FXSYS_memset(dest_scan, gray, width);
+ } else {
+ for (int col = 0; col < width; col++) {
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
+ dest_scan++;
+ }
+ }
+ }
+ return true;
+ }
+ if (m_bpp == 1) {
+ ASSERT(!IsCmykImage() && static_cast<uint8_t>(alpha_flag >> 8) == 0);
+ int left_shift = rect.left % 8;
+ int right_shift = rect.right % 8;
+ int new_width = rect.right / 8 - rect.left / 8;
+ int index = 0;
+ if (m_pPalette) {
+ for (int i = 0; i < 2; i++) {
+ if (m_pPalette.get()[i] == color)
+ index = i;
+ }
+ } else {
+ index = (static_cast<uint8_t>(color) == 0xff) ? 1 : 0;
+ }
+ for (int row = rect.top; row < rect.bottom; row++) {
+ uint8_t* dest_scan_top =
+ const_cast<uint8_t*>(GetScanline(row)) + rect.left / 8;
+ uint8_t* dest_scan_top_r =
+ const_cast<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 (new_width) {
+ FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, new_width - 1);
+ if (!index) {
+ *dest_scan_top &= left_flag;
+ *dest_scan_top_r &= right_flag;
+ } else {
+ *dest_scan_top |= ~left_flag;
+ *dest_scan_top_r |= ~right_flag;
+ }
+ } else {
+ if (!index) {
+ *dest_scan_top &= left_flag | right_flag;
+ } else {
+ *dest_scan_top |= ~(left_flag | right_flag);
+ }
+ }
+ }
+ return true;
+ }
+ ASSERT(m_bpp >= 24);
+ if (m_bpp < 24) {
+ return false;
+ }
+ if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
+ CCodec_IccModule* pIccModule =
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+ pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
+ } else {
+ if (alpha_flag >> 8 && !IsCmykImage()) {
+ AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
+ FXSYS_GetYValue(color), FXSYS_GetKValue(color),
+ color_p[2], color_p[1], color_p[0]);
+ } else if (!(alpha_flag >> 8) && IsCmykImage()) {
+ return false;
+ }
+ }
+ if (!IsCmykImage()) {
+ color_p[3] = (uint8_t)src_alpha;
+ }
+ int Bpp = m_bpp / 8;
+ bool bAlpha = HasAlpha();
+ bool bArgb = GetFormat() == FXDIB_Argb;
+ if (src_alpha == 255) {
+ for (int row = rect.top; row < rect.bottom; row++) {
+ uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
+ uint8_t* dest_scan_alpha =
+ m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left
+ : nullptr;
+ if (dest_scan_alpha) {
+ FXSYS_memset(dest_scan_alpha, 0xff, width);
+ }
+ if (Bpp == 4) {
+ uint32_t* scan = (uint32_t*)dest_scan;
+ for (int col = 0; col < width; col++) {
+ *scan++ = dst_color;
+ }
+ } else {
+ for (int col = 0; col < width; col++) {
+ *dest_scan++ = color_p[0];
+ *dest_scan++ = color_p[1];
+ *dest_scan++ = color_p[2];
+ }
+ }
+ }
+ return true;
+ }
+ for (int row = rect.top; row < rect.bottom; row++) {
+ uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
+ if (bAlpha) {
+ if (bArgb) {
+ for (int col = 0; col < width; col++) {
+ uint8_t back_alpha = dest_scan[3];
+ if (back_alpha == 0) {
+ FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, color_p[2],
+ color_p[1], color_p[0]));
+ dest_scan += 4;
+ continue;
+ }
+ uint8_t dest_alpha =
+ back_alpha + src_alpha - back_alpha * src_alpha / 255;
+ int alpha_ratio = src_alpha * 255 / dest_alpha;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[0], alpha_ratio);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[1], alpha_ratio);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[2], alpha_ratio);
+ dest_scan++;
+ *dest_scan++ = dest_alpha;
+ }
+ } else {
+ uint8_t* dest_scan_alpha =
+ (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left;
+ for (int col = 0; col < width; col++) {
+ uint8_t back_alpha = *dest_scan_alpha;
+ if (back_alpha == 0) {
+ *dest_scan_alpha++ = src_alpha;
+ FXSYS_memcpy(dest_scan, color_p, Bpp);
+ dest_scan += Bpp;
+ continue;
+ }
+ uint8_t dest_alpha =
+ back_alpha + src_alpha - back_alpha * src_alpha / 255;
+ *dest_scan_alpha++ = dest_alpha;
+ int alpha_ratio = src_alpha * 255 / dest_alpha;
+ for (int comps = 0; comps < Bpp; comps++) {
+ *dest_scan =
+ FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], alpha_ratio);
+ dest_scan++;
+ }
+ }
+ }
+ } else {
+ for (int col = 0; col < width; col++) {
+ for (int comps = 0; comps < Bpp; comps++) {
+ if (comps == 3) {
+ *dest_scan++ = 255;
+ continue;
+ }
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], src_alpha);
+ dest_scan++;
+ }
+ }
+ }
+ }
+ return true;
+}
+
+bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) {
+ FXDIB_Format src_format = GetFormat();
+ if (dest_format == src_format)
+ return true;
+
+ if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
+ !m_pPalette) {
+ m_AlphaFlag = 1;
+ return true;
+ }
+ if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32) {
+ m_AlphaFlag = 2;
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* scanline = m_pBuffer + row * m_Pitch + 3;
+ for (int col = 0; col < m_Width; col++) {
+ *scanline = 0xff;
+ scanline += 4;
+ }
+ }
+ return true;
+ }
+ int dest_bpp = dest_format & 0xff;
+ int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
+ uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
+ if (!dest_buf) {
+ return false;
+ }
+ CFX_RetainPtr<CFX_DIBitmap> pAlphaMask;
+ if (dest_format == FXDIB_Argb) {
+ FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
+ if (m_pAlphaMask) {
+ for (int row = 0; row < m_Height; row++) {
+ uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
+ const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
+ for (int col = 0; col < m_Width; col++) {
+ *pDstScanline = *pSrcScanline++;
+ pDstScanline += 4;
+ }
+ }
+ }
+ } else if (dest_format & 0x0200) {
+ if (src_format == FXDIB_Argb) {
+ pAlphaMask = CloneAlphaMask();
+ if (!pAlphaMask) {
+ FX_Free(dest_buf);
+ return false;
+ }
+ } else {
+ if (!m_pAlphaMask) {
+ if (!BuildAlphaMask()) {
+ FX_Free(dest_buf);
+ return false;
+ }
+ pAlphaMask = std::move(m_pAlphaMask);
+ } else {
+ pAlphaMask = m_pAlphaMask;
+ }
+ }
+ }
+ bool ret = false;
+ CFX_RetainPtr<CFX_DIBSource> holder(this);
+ std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
+ ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
+ holder, 0, 0, &pal_8bpp);
+ if (!ret) {
+ FX_Free(dest_buf);
+ return false;
+ }
+ m_pAlphaMask = pAlphaMask;
+ m_pPalette = std::move(pal_8bpp);
+ if (!m_bExtBuf)
+ FX_Free(m_pBuffer);
+ m_bExtBuf = false;
+ m_pBuffer = dest_buf;
+ m_bpp = (uint8_t)dest_format;
+ m_AlphaFlag = (uint8_t)(dest_format >> 8);
+ m_Pitch = dest_pitch;
+ return true;
+}
diff --git a/core/fxge/dib/fx_dib_composite.cpp b/core/fxge/dib/fx_dib_composite.cpp
index 86be539008..e7912e5a1b 100644
--- a/core/fxge/dib/fx_dib_composite.cpp
+++ b/core/fxge/dib/fx_dib_composite.cpp
@@ -10,359 +10,6 @@
#include "core/fxge/cfx_gemodule.h"
#include "core/fxge/ge/cfx_cliprgn.h"
-bool CFX_DIBitmap::CompositeBitmap(
- int dest_left,
- int dest_top,
- int width,
- int height,
- const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
- int src_left,
- int src_top,
- int blend_type,
- const CFX_ClipRgn* pClipRgn,
- bool bRgbByteOrder,
- void* pIccTransform) {
- 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) {
- return true;
- }
- CFX_RetainPtr<CFX_DIBitmap> pClipMask;
- FX_RECT clip_box;
- if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
- ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
- pClipMask = pClipRgn->GetMask();
- clip_box = pClipRgn->GetBox();
- }
- CFX_ScanlineCompositor compositor;
- if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width,
- pSrcBitmap->GetPalette(), 0, blend_type,
- pClipMask != nullptr, bRgbByteOrder, 0, pIccTransform)) {
- return false;
- }
- int dest_Bpp = m_bpp / 8;
- int src_Bpp = pSrcBitmap->GetBPP() / 8;
- bool bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
- CFX_RetainPtr<CFX_DIBitmap> pSrcAlphaMask = pSrcBitmap->m_pAlphaMask;
- for (int row = 0; row < height; row++) {
- uint8_t* dest_scan =
- m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
- const uint8_t* src_scan =
- pSrcBitmap->GetScanline(src_top + row) + src_left * src_Bpp;
- const uint8_t* src_scan_extra_alpha =
- pSrcAlphaMask ? pSrcAlphaMask->GetScanline(src_top + row) + src_left
- : nullptr;
- uint8_t* dst_scan_extra_alpha =
- m_pAlphaMask
- ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
- : nullptr;
- const uint8_t* clip_scan = nullptr;
- if (pClipMask) {
- clip_scan = pClipMask->m_pBuffer +
- (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
- (dest_left - clip_box.left);
- }
- if (bRgb) {
- compositor.CompositeRgbBitmapLine(dest_scan, src_scan, width, clip_scan,
- src_scan_extra_alpha,
- dst_scan_extra_alpha);
- } else {
- compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width,
- clip_scan, src_scan_extra_alpha,
- dst_scan_extra_alpha);
- }
- }
- return true;
-}
-
-bool CFX_DIBitmap::CompositeMask(int dest_left,
- int dest_top,
- int width,
- int height,
- const CFX_RetainPtr<CFX_DIBSource>& pMask,
- uint32_t color,
- int src_left,
- int src_top,
- int blend_type,
- const CFX_ClipRgn* pClipRgn,
- bool bRgbByteOrder,
- int alpha_flag,
- void* pIccTransform) {
- 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) {
- return true;
- }
- int src_alpha =
- (uint8_t)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
- if (src_alpha == 0) {
- return true;
- }
- CFX_RetainPtr<CFX_DIBitmap> pClipMask;
- FX_RECT clip_box;
- if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::RectI) {
- ASSERT(pClipRgn->GetType() == CFX_ClipRgn::MaskF);
- pClipMask = pClipRgn->GetMask();
- clip_box = pClipRgn->GetBox();
- }
- int src_bpp = pMask->GetBPP();
- int Bpp = GetBPP() / 8;
- CFX_ScanlineCompositor compositor;
- if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, nullptr, color,
- blend_type, pClipMask != nullptr, bRgbByteOrder,
- alpha_flag, pIccTransform)) {
- return false;
- }
- for (int row = 0; row < height; row++) {
- uint8_t* dest_scan =
- m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
- const uint8_t* src_scan = pMask->GetScanline(src_top + row);
- uint8_t* dst_scan_extra_alpha =
- m_pAlphaMask
- ? (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left
- : nullptr;
- const uint8_t* clip_scan = nullptr;
- if (pClipMask) {
- clip_scan = pClipMask->m_pBuffer +
- (dest_top + row - clip_box.top) * pClipMask->m_Pitch +
- (dest_left - clip_box.left);
- }
- if (src_bpp == 1) {
- compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width,
- clip_scan, dst_scan_extra_alpha);
- } else {
- compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width,
- clip_scan, dst_scan_extra_alpha);
- }
- }
- return true;
-}
-
-bool CFX_DIBitmap::CompositeRect(int left,
- int top,
- int width,
- int height,
- uint32_t color,
- int alpha_flag,
- void* pIccTransform) {
- 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;
- }
- width = rect.Width();
- uint32_t dst_color;
- if (alpha_flag >> 8) {
- dst_color = FXCMYK_TODIB(color);
- } else {
- dst_color = FXARGB_TODIB(color);
- }
- uint8_t* color_p = (uint8_t*)&dst_color;
- if (m_bpp == 8) {
- uint8_t gray = 255;
- if (!IsAlphaMask()) {
- if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
- CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
- CCodec_IccModule* pIccModule =
- CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
- pIccModule->TranslateScanline(pIccTransform, &gray, color_p, 1);
- } else {
- if (alpha_flag >> 8) {
- uint8_t r, g, b;
- AdobeCMYK_to_sRGB1(color_p[0], color_p[1], color_p[2], color_p[3], r,
- g, b);
- gray = FXRGB2GRAY(r, g, b);
- } else {
- gray = (uint8_t)FXRGB2GRAY((int)color_p[2], color_p[1], color_p[0]);
- }
- }
- if (IsCmykImage()) {
- gray = ~gray;
- }
- }
- for (int row = rect.top; row < rect.bottom; row++) {
- uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left;
- if (src_alpha == 255) {
- FXSYS_memset(dest_scan, gray, width);
- } else {
- for (int col = 0; col < width; col++) {
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
- dest_scan++;
- }
- }
- }
- 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 new_width = rect.right / 8 - rect.left / 8;
- int index = 0;
- if (m_pPalette) {
- for (int i = 0; i < 2; i++) {
- if (m_pPalette.get()[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 (new_width) {
- FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, new_width - 1);
- if (!index) {
- *dest_scan_top &= left_flag;
- *dest_scan_top_r &= right_flag;
- } else {
- *dest_scan_top |= ~left_flag;
- *dest_scan_top_r |= ~right_flag;
- }
- } else {
- if (!index) {
- *dest_scan_top &= left_flag | right_flag;
- } else {
- *dest_scan_top |= ~(left_flag | right_flag);
- }
- }
- }
- return true;
- }
- ASSERT(m_bpp >= 24);
- if (m_bpp < 24) {
- return false;
- }
- if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
- CCodec_IccModule* pIccModule =
- CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
- pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
- } else {
- if (alpha_flag >> 8 && !IsCmykImage()) {
- AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
- FXSYS_GetYValue(color), FXSYS_GetKValue(color),
- color_p[2], color_p[1], color_p[0]);
- } else if (!(alpha_flag >> 8) && IsCmykImage()) {
- return false;
- }
- }
- if (!IsCmykImage()) {
- color_p[3] = (uint8_t)src_alpha;
- }
- int Bpp = m_bpp / 8;
- bool bAlpha = HasAlpha();
- bool bArgb = GetFormat() == FXDIB_Argb;
- if (src_alpha == 255) {
- for (int row = rect.top; row < rect.bottom; row++) {
- uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
- uint8_t* dest_scan_alpha =
- m_pAlphaMask ? (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left
- : nullptr;
- if (dest_scan_alpha) {
- FXSYS_memset(dest_scan_alpha, 0xff, width);
- }
- if (Bpp == 4) {
- uint32_t* scan = (uint32_t*)dest_scan;
- for (int col = 0; col < width; col++) {
- *scan++ = dst_color;
- }
- } else {
- for (int col = 0; col < width; col++) {
- *dest_scan++ = color_p[0];
- *dest_scan++ = color_p[1];
- *dest_scan++ = color_p[2];
- }
- }
- }
- return true;
- }
- for (int row = rect.top; row < rect.bottom; row++) {
- uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
- if (bAlpha) {
- if (bArgb) {
- for (int col = 0; col < width; col++) {
- uint8_t back_alpha = dest_scan[3];
- if (back_alpha == 0) {
- FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, color_p[2],
- color_p[1], color_p[0]));
- dest_scan += 4;
- continue;
- }
- uint8_t dest_alpha =
- back_alpha + src_alpha - back_alpha * src_alpha / 255;
- int alpha_ratio = src_alpha * 255 / dest_alpha;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[0], alpha_ratio);
- dest_scan++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[1], alpha_ratio);
- dest_scan++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[2], alpha_ratio);
- dest_scan++;
- *dest_scan++ = dest_alpha;
- }
- } else {
- uint8_t* dest_scan_alpha =
- (uint8_t*)m_pAlphaMask->GetScanline(row) + rect.left;
- for (int col = 0; col < width; col++) {
- uint8_t back_alpha = *dest_scan_alpha;
- if (back_alpha == 0) {
- *dest_scan_alpha++ = src_alpha;
- FXSYS_memcpy(dest_scan, color_p, Bpp);
- dest_scan += Bpp;
- continue;
- }
- uint8_t dest_alpha =
- back_alpha + src_alpha - back_alpha * src_alpha / 255;
- *dest_scan_alpha++ = dest_alpha;
- int alpha_ratio = src_alpha * 255 / dest_alpha;
- for (int comps = 0; comps < Bpp; comps++) {
- *dest_scan =
- FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], alpha_ratio);
- dest_scan++;
- }
- }
- }
- } else {
- for (int col = 0; col < width; col++) {
- for (int comps = 0; comps < Bpp; comps++) {
- if (comps == 3) {
- *dest_scan++ = 255;
- continue;
- }
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, color_p[comps], src_alpha);
- dest_scan++;
- }
- }
- }
- }
- return true;
-}
-
CFX_BitmapComposer::CFX_BitmapComposer() {
m_pScanlineV = nullptr;
m_pScanlineAlphaV = nullptr;
diff --git a/core/fxge/dib/fx_dib_convert.cpp b/core/fxge/dib/fx_dib_convert.cpp
index 419e6547e4..d3cff24326 100644
--- a/core/fxge/dib/fx_dib_convert.cpp
+++ b/core/fxge/dib/fx_dib_convert.cpp
@@ -12,6 +12,8 @@
#include "core/fxge/fx_dib.h"
#include "third_party/base/ptr_util.h"
+namespace {
+
class CFX_Palette {
public:
CFX_Palette();
@@ -657,6 +659,8 @@ bool ConvertBuffer_32bppCmyk2Rgb32(
return true;
}
+} // namespace
+
bool ConvertBuffer(FXDIB_Format dest_format,
uint8_t* dest_buf,
int dest_pitch,
@@ -786,83 +790,3 @@ bool ConvertBuffer(FXDIB_Format dest_format,
return false;
}
}
-
-bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) {
- FXDIB_Format src_format = GetFormat();
- if (dest_format == src_format)
- return true;
-
- if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
- !m_pPalette) {
- m_AlphaFlag = 1;
- return true;
- }
- if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32) {
- m_AlphaFlag = 2;
- for (int row = 0; row < m_Height; row++) {
- uint8_t* scanline = m_pBuffer + row * m_Pitch + 3;
- for (int col = 0; col < m_Width; col++) {
- *scanline = 0xff;
- scanline += 4;
- }
- }
- return true;
- }
- int dest_bpp = dest_format & 0xff;
- int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
- uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
- if (!dest_buf) {
- return false;
- }
- CFX_RetainPtr<CFX_DIBitmap> pAlphaMask;
- if (dest_format == FXDIB_Argb) {
- FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
- if (m_pAlphaMask) {
- for (int row = 0; row < m_Height; row++) {
- uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
- const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
- for (int col = 0; col < m_Width; col++) {
- *pDstScanline = *pSrcScanline++;
- pDstScanline += 4;
- }
- }
- }
- } else if (dest_format & 0x0200) {
- if (src_format == FXDIB_Argb) {
- pAlphaMask = CloneAlphaMask();
- if (!pAlphaMask) {
- FX_Free(dest_buf);
- return false;
- }
- } else {
- if (!m_pAlphaMask) {
- if (!BuildAlphaMask()) {
- FX_Free(dest_buf);
- return false;
- }
- pAlphaMask = std::move(m_pAlphaMask);
- } else {
- pAlphaMask = m_pAlphaMask;
- }
- }
- }
- bool ret = false;
- CFX_RetainPtr<CFX_DIBSource> holder(this);
- std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
- ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
- holder, 0, 0, &pal_8bpp);
- if (!ret) {
- FX_Free(dest_buf);
- return false;
- }
- m_pAlphaMask = pAlphaMask;
- m_pPalette = std::move(pal_8bpp);
- if (!m_bExtBuf)
- FX_Free(m_pBuffer);
- m_bExtBuf = false;
- m_pBuffer = dest_buf;
- m_bpp = (uint8_t)dest_format;
- m_AlphaFlag = (uint8_t)(dest_format >> 8);
- m_Pitch = dest_pitch;
- return true;
-}
diff --git a/core/fxge/dib/fx_dib_main.cpp b/core/fxge/dib/fx_dib_main.cpp
index 2ea3eeab3e..f3716c36b1 100644
--- a/core/fxge/dib/fx_dib_main.cpp
+++ b/core/fxge/dib/fx_dib_main.cpp
@@ -6,18 +6,9 @@
#include "core/fxge/fx_dib.h"
-#include <limits.h>
-
-#include <algorithm>
-#include <memory>
#include <utility>
-#include "core/fxcodec/fx_codec.h"
-#include "core/fxcrt/cfx_maybe_owned.h"
-#include "core/fxge/cfx_gemodule.h"
-#include "core/fxge/dib/cfx_filtereddib.h"
#include "core/fxge/dib/dib_int.h"
-#include "core/fxge/ge/cfx_cliprgn.h"
#include "third_party/base/ptr_util.h"
const int16_t SDP_Table[513] = {
@@ -106,1045 +97,6 @@ uint32_t ArgbEncode(int a, FX_COLORREF rgb) {
FXSYS_GetBValue(rgb));
}
-CFX_DIBitmap::CFX_DIBitmap() {
- m_bExtBuf = false;
- m_pBuffer = nullptr;
- m_pPalette = nullptr;
-#ifdef _SKIA_SUPPORT_PATHS_
- m_nFormat = Format::kCleared;
-#endif
-}
-
-#define _MAX_OOM_LIMIT_ 12000000
-bool CFX_DIBitmap::Create(int width,
- int height,
- FXDIB_Format format,
- uint8_t* pBuffer,
- int pitch) {
- m_pBuffer = nullptr;
- m_bpp = (uint8_t)format;
- m_AlphaFlag = (uint8_t)(format >> 8);
- m_Width = m_Height = m_Pitch = 0;
- if (width <= 0 || height <= 0 || pitch < 0) {
- return false;
- }
- if ((INT_MAX - 31) / width < (format & 0xff)) {
- return false;
- }
- if (!pitch) {
- pitch = (width * (format & 0xff) + 31) / 32 * 4;
- }
- if ((1 << 30) / pitch < height) {
- return false;
- }
- if (pBuffer) {
- m_pBuffer = pBuffer;
- m_bExtBuf = true;
- } else {
- int size = pitch * height + 4;
- int oomlimit = _MAX_OOM_LIMIT_;
- if (oomlimit >= 0 && size >= oomlimit) {
- m_pBuffer = FX_TryAlloc(uint8_t, size);
- if (!m_pBuffer) {
- return false;
- }
- } else {
- m_pBuffer = FX_Alloc(uint8_t, size);
- }
- }
- m_Width = width;
- m_Height = height;
- m_Pitch = pitch;
- if (HasAlpha() && format != FXDIB_Argb) {
- bool ret = true;
- ret = BuildAlphaMask();
- if (!ret) {
- if (!m_bExtBuf) {
- FX_Free(m_pBuffer);
- m_pBuffer = nullptr;
- m_Width = m_Height = m_Pitch = 0;
- return false;
- }
- }
- }
- return true;
-}
-
-bool CFX_DIBitmap::Copy(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
- if (m_pBuffer)
- return false;
-
- if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat()))
- return false;
-
- SetPalette(pSrc->GetPalette());
- SetAlphaMask(pSrc->m_pAlphaMask);
- for (int row = 0; row < pSrc->GetHeight(); row++)
- FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
-
- return true;
-}
-
-CFX_DIBitmap::~CFX_DIBitmap() {
- if (!m_bExtBuf)
- FX_Free(m_pBuffer);
-
- m_pBuffer = nullptr;
-}
-
-uint8_t* CFX_DIBitmap::GetBuffer() const {
- return m_pBuffer;
-}
-
-const uint8_t* CFX_DIBitmap::GetScanline(int line) const {
- return m_pBuffer ? m_pBuffer + line * m_Pitch : nullptr;
-}
-
-void CFX_DIBitmap::TakeOver(CFX_RetainPtr<CFX_DIBitmap>&& pSrcBitmap) {
- if (!m_bExtBuf)
- FX_Free(m_pBuffer);
-
- m_pBuffer = pSrcBitmap->m_pBuffer;
- m_pPalette = std::move(pSrcBitmap->m_pPalette);
- m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
- pSrcBitmap->m_pBuffer = 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;
-}
-
-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: {
- int index = FindPalette(color);
- FXSYS_memset(m_pBuffer, index ? 0xff : 0, m_Pitch * m_Height);
- break;
- }
- case FXDIB_8bppMask:
- FXSYS_memset(m_pBuffer, color >> 24, m_Pitch * m_Height);
- break;
- case FXDIB_8bppRgb: {
- int index = FindPalette(color);
- FXSYS_memset(m_pBuffer, index, m_Pitch * m_Height);
- break;
- }
- case FXDIB_Rgb:
- case FXDIB_Rgba: {
- int a, r, g, b;
- ArgbDecode(color, a, r, g, b);
- if (r == g && g == b) {
- FXSYS_memset(m_pBuffer, r, m_Pitch * m_Height);
- } else {
- int byte_pos = 0;
- for (int col = 0; col < m_Width; col++) {
- m_pBuffer[byte_pos++] = b;
- m_pBuffer[byte_pos++] = g;
- m_pBuffer[byte_pos++] = r;
- }
- for (int row = 1; row < m_Height; row++) {
- FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
- }
- }
- break;
- }
- case FXDIB_Rgb32:
- case FXDIB_Argb: {
- color = IsCmykImage() ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-#ifdef _SKIA_SUPPORT_
- if (FXDIB_Rgb32 == GetFormat() && !IsCmykImage()) {
- color |= 0xFF000000;
- }
-#endif
- for (int i = 0; i < m_Width; i++) {
- ((uint32_t*)m_pBuffer)[i] = color;
- }
- for (int row = 1; row < m_Height; row++) {
- FXSYS_memcpy(m_pBuffer + row * m_Pitch, m_pBuffer, m_Pitch);
- }
- break;
- }
- default:
- break;
- }
-}
-
-bool CFX_DIBitmap::TransferBitmap(
- int dest_left,
- int dest_top,
- int width,
- int height,
- const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
- int src_left,
- int src_top) {
- if (!m_pBuffer)
- return false;
-
- GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
- pSrcBitmap->GetHeight(), src_left, src_top, nullptr);
- if (width == 0 || height == 0)
- return true;
-
- FXDIB_Format dest_format = GetFormat();
- FXDIB_Format src_format = pSrcBitmap->GetFormat();
- if (dest_format == src_format) {
- if (GetBPP() == 1) {
- for (int row = 0; row < height; row++) {
- uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
- const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
- for (int col = 0; col < width; col++) {
- if (src_scan[(src_left + col) / 8] &
- (1 << (7 - (src_left + col) % 8))) {
- dest_scan[(dest_left + col) / 8] |= 1
- << (7 - (dest_left + col) % 8);
- } else {
- dest_scan[(dest_left + col) / 8] &=
- ~(1 << (7 - (dest_left + col) % 8));
- }
- }
- }
- } else {
- int Bpp = GetBPP() / 8;
- for (int row = 0; row < height; row++) {
- uint8_t* dest_scan =
- m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
- const uint8_t* src_scan =
- pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
- FXSYS_memcpy(dest_scan, src_scan, width * Bpp);
- }
- }
- } 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;
- 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)) {
- return false;
- }
- }
- return true;
-}
-
-bool CFX_DIBitmap::TransferMask(int dest_left,
- int dest_top,
- int width,
- int height,
- const CFX_RetainPtr<CFX_DIBSource>& pMask,
- uint32_t color,
- int src_left,
- int src_top,
- int alpha_flag,
- void* pIccTransform) {
- if (!m_pBuffer) {
- return false;
- }
- ASSERT(HasAlpha() && (m_bpp >= 24));
- ASSERT(pMask->IsAlphaMask());
- if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
- return false;
- }
- GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
- pMask->GetHeight(), src_left, src_top, nullptr);
- if (width == 0 || height == 0) {
- return true;
- }
- int src_bpp = pMask->GetBPP();
- int alpha;
- uint32_t dst_color;
- if (alpha_flag >> 8) {
- alpha = alpha_flag & 0xff;
- dst_color = FXCMYK_TODIB(color);
- } else {
- alpha = FXARGB_A(color);
- dst_color = FXARGB_TODIB(color);
- }
- uint8_t* color_p = (uint8_t*)&dst_color;
- if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() &&
- CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
- CCodec_IccModule* pIccModule =
- CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
- pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
- } else {
- if (alpha_flag >> 8 && !IsCmykImage()) {
- AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
- FXSYS_GetYValue(color), FXSYS_GetKValue(color),
- color_p[2], color_p[1], color_p[0]);
- } else if (!(alpha_flag >> 8) && IsCmykImage()) {
- return false;
- }
- }
- if (!IsCmykImage()) {
- color_p[3] = (uint8_t)alpha;
- }
- if (GetFormat() == FXDIB_Argb) {
- for (int row = 0; row < height; row++) {
- uint32_t* dest_pos =
- (uint32_t*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
- const uint8_t* src_scan = pMask->GetScanline(src_top + row);
- if (src_bpp == 1) {
- for (int col = 0; col < width; col++) {
- int src_bitpos = src_left + col;
- if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
- *dest_pos = dst_color;
- } else {
- *dest_pos = 0;
- }
- dest_pos++;
- }
- } else {
- src_scan += src_left;
- dst_color = FXARGB_TODIB(dst_color);
- dst_color &= 0xffffff;
- for (int col = 0; col < width; col++) {
- FXARGB_SETDIB(dest_pos++,
- dst_color | ((alpha * (*src_scan++) / 255) << 24));
- }
- }
- }
- } else {
- int comps = m_bpp / 8;
- for (int row = 0; row < height; row++) {
- uint8_t* dest_color_pos =
- m_pBuffer + (dest_top + row) * m_Pitch + dest_left * comps;
- uint8_t* dest_alpha_pos =
- (uint8_t*)m_pAlphaMask->GetScanline(dest_top + row) + dest_left;
- const uint8_t* src_scan = pMask->GetScanline(src_top + row);
- if (src_bpp == 1) {
- for (int col = 0; col < width; col++) {
- int src_bitpos = src_left + col;
- if (src_scan[src_bitpos / 8] & (1 << (7 - src_bitpos % 8))) {
- FXSYS_memcpy(dest_color_pos, color_p, comps);
- *dest_alpha_pos = 0xff;
- } else {
- FXSYS_memset(dest_color_pos, 0, comps);
- *dest_alpha_pos = 0;
- }
- dest_color_pos += comps;
- dest_alpha_pos++;
- }
- } else {
- src_scan += src_left;
- 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;
-}
-
-const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
-bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
- const CFX_RetainPtr<CFX_DIBSource>& pSrcBitmap,
- FXDIB_Channel srcChannel) {
- if (!m_pBuffer)
- return false;
-
- CFX_RetainPtr<CFX_DIBSource> pSrcClone = pSrcBitmap;
- int srcOffset;
- if (srcChannel == FXDIB_Alpha) {
- if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask())
- return false;
-
- if (pSrcBitmap->GetBPP() == 1) {
- pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
- if (!pSrcClone)
- return false;
- }
- srcOffset = pSrcBitmap->GetFormat() == FXDIB_Argb ? 3 : 0;
- } else {
- if (pSrcBitmap->IsAlphaMask())
- return false;
-
- if (pSrcBitmap->GetBPP() < 24) {
- if (pSrcBitmap->IsCmykImage()) {
- pSrcClone = pSrcBitmap->CloneConvert(static_cast<FXDIB_Format>(
- (pSrcBitmap->GetFormat() & 0xff00) | 0x20));
- } else {
- pSrcClone = pSrcBitmap->CloneConvert(static_cast<FXDIB_Format>(
- (pSrcBitmap->GetFormat() & 0xff00) | 0x18));
- }
- if (!pSrcClone)
- return false;
- }
- srcOffset = g_ChannelOffset[srcChannel];
- }
- int destOffset = 0;
- if (destChannel == FXDIB_Alpha) {
- if (IsAlphaMask()) {
- if (!ConvertFormat(FXDIB_8bppMask))
- return false;
- } else {
- if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
- return false;
-
- if (GetFormat() == FXDIB_Argb)
- destOffset = 3;
- }
- } else {
- if (IsAlphaMask())
- return false;
-
- if (GetBPP() < 24) {
- if (HasAlpha()) {
- if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb))
- return false;
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
- } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-#else
- } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-#endif
- return false;
- }
- }
- destOffset = g_ChannelOffset[destChannel];
- }
- if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
- CFX_RetainPtr<CFX_DIBSource> pAlphaMask = pSrcClone->m_pAlphaMask;
- if (pSrcClone->GetWidth() != m_Width ||
- pSrcClone->GetHeight() != m_Height) {
- if (pAlphaMask) {
- pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
- if (!pAlphaMask)
- return false;
- }
- }
- pSrcClone = std::move(pAlphaMask);
- srcOffset = 0;
- } else if (pSrcClone->GetWidth() != m_Width ||
- pSrcClone->GetHeight() != m_Height) {
- CFX_RetainPtr<CFX_DIBitmap> pSrcMatched =
- pSrcClone->StretchTo(m_Width, m_Height);
- if (!pSrcMatched)
- return false;
-
- pSrcClone = std::move(pSrcMatched);
- }
- CFX_RetainPtr<CFX_DIBitmap> pDst(this);
- if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
- pDst = m_pAlphaMask;
- destOffset = 0;
- }
- int srcBytes = pSrcClone->GetBPP() / 8;
- int destBytes = pDst->GetBPP() / 8;
- for (int row = 0; row < m_Height; row++) {
- uint8_t* dest_pos = (uint8_t*)pDst->GetScanline(row) + destOffset;
- const uint8_t* src_pos = pSrcClone->GetScanline(row) + srcOffset;
- for (int col = 0; col < m_Width; col++) {
- *dest_pos = *src_pos;
- dest_pos += destBytes;
- src_pos += srcBytes;
- }
- }
- return true;
-}
-
-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;
- }
- destOffset = 0;
- } else {
- destOffset = 0;
- if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
- return false;
- }
- if (GetFormat() == FXDIB_Argb) {
- destOffset = 3;
- }
- }
- } else {
- if (IsAlphaMask()) {
- return false;
- }
- if (GetBPP() < 24) {
- if (HasAlpha()) {
- if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
- return false;
- }
-#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
- } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-#else
- } else if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-#endif
- return false;
- }
- }
- destOffset = g_ChannelOffset[destChannel];
- }
- int Bpp = GetBPP() / 8;
- if (Bpp == 1) {
- FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
- return true;
- }
- if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
- FXSYS_memset(m_pAlphaMask->GetBuffer(), value,
- m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
- return true;
- }
- 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;
-}
-
-bool CFX_DIBitmap::MultiplyAlpha(
- const CFX_RetainPtr<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);
-
- CFX_RetainPtr<CFX_DIBitmap> pSrcClone = pSrcBitmap.As<CFX_DIBitmap>();
- if (pSrcBitmap->GetWidth() != m_Width ||
- pSrcBitmap->GetHeight() != m_Height) {
- pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
- if (!pSrcClone)
- return false;
- }
- if (IsAlphaMask()) {
- if (!ConvertFormat(FXDIB_8bppMask))
- return false;
-
- for (int row = 0; row < m_Height; row++) {
- uint8_t* dest_scan = m_pBuffer + m_Pitch * row;
- uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
- if (pSrcClone->GetBPP() == 1) {
- for (int col = 0; col < m_Width; col++) {
- if (!((1 << (7 - col % 8)) & src_scan[col / 8]))
- dest_scan[col] = 0;
- }
- } else {
- for (int col = 0; col < m_Width; col++) {
- *dest_scan = (*dest_scan) * src_scan[col] / 255;
- dest_scan++;
- }
- }
- }
- } else {
- if (GetFormat() == FXDIB_Argb) {
- if (pSrcClone->GetBPP() == 1)
- return false;
-
- for (int row = 0; row < m_Height; row++) {
- uint8_t* dest_scan = m_pBuffer + m_Pitch * row + 3;
- uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
- for (int col = 0; col < m_Width; col++) {
- *dest_scan = (*dest_scan) * src_scan[col] / 255;
- dest_scan += 4;
- }
- }
- } else {
- m_pAlphaMask->MultiplyAlpha(pSrcClone);
- }
- }
- return true;
-}
-
-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 = 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));
- }
- auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
- if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
- 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(std::move(pMask));
- break;
- }
- case FXDIB_8bppRgb: {
- if (!m_pPalette)
- return false;
-
- uint8_t gray[256];
- for (int i = 0; i < 256; i++) {
- 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));
- }
- auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
- if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
- 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++) {
- *dest_pos++ = gray[*src_pos++];
- }
- }
- TakeOver(std::move(pMask));
- break;
- }
- case FXDIB_Rgb: {
- auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
- if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
- return false;
-
- for (int row = 0; row < m_Height; row++) {
- uint8_t* src_pos = m_pBuffer + row * m_Pitch;
- uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
- for (int col = 0; col < m_Width; col++) {
- *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
- src_pos += 3;
- }
- }
- TakeOver(std::move(pMask));
- break;
- }
- case FXDIB_Rgb32: {
- auto pMask = pdfium::MakeRetain<CFX_DIBitmap>();
- if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask))
- return false;
-
- for (int row = 0; row < m_Height; row++) {
- uint8_t* src_pos = m_pBuffer + row * m_Pitch;
- uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
- for (int col = 0; col < m_Width; col++) {
- *dest_pos++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
- src_pos += 4;
- }
- }
- TakeOver(std::move(pMask));
- break;
- }
- default:
- return false;
- }
- return true;
-}
-
-bool CFX_DIBitmap::MultiplyAlpha(int alpha) {
- if (!m_pBuffer) {
- return false;
- }
- switch (GetFormat()) {
- case FXDIB_1bppMask:
- if (!ConvertFormat(FXDIB_8bppMask)) {
- return false;
- }
- MultiplyAlpha(alpha);
- break;
- case FXDIB_8bppMask: {
- for (int row = 0; row < m_Height; row++) {
- uint8_t* scan_line = m_pBuffer + row * m_Pitch;
- for (int col = 0; col < m_Width; col++) {
- scan_line[col] = scan_line[col] * alpha / 255;
- }
- }
- break;
- }
- case FXDIB_Argb: {
- for (int row = 0; row < m_Height; row++) {
- uint8_t* scan_line = m_pBuffer + row * m_Pitch + 3;
- for (int col = 0; col < m_Width; col++) {
- *scan_line = (*scan_line) * alpha / 255;
- scan_line += 4;
- }
- }
- break;
- }
- default:
- if (HasAlpha()) {
- m_pAlphaMask->MultiplyAlpha(alpha);
- } else if (IsCmykImage()) {
- if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
- return false;
- }
- m_pAlphaMask->MultiplyAlpha(alpha);
- } 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.get()[1] : 0xffffffff;
- }
- return m_pPalette ? m_pPalette.get()[0] : 0xff000000;
- }
- case FXDIB_8bppMask:
- return (*pos) << 24;
- case FXDIB_8bppRgb:
- 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.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.get()[i] == color) {
- *pos = (uint8_t)i;
- return;
- }
- }
- *pos = 0;
- } else {
- *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
- }
- break;
- }
- case FXDIB_Rgb:
- case FXDIB_Rgb32: {
- int alpha = FXARGB_A(color);
- pos[0] = (FXARGB_B(color) * alpha + pos[0] * (255 - alpha)) / 255;
- pos[1] = (FXARGB_G(color) * alpha + pos[1] * (255 - alpha)) / 255;
- pos[2] = (FXARGB_R(color) * alpha + pos[2] * (255 - alpha)) / 255;
- break;
- }
- case FXDIB_Rgba: {
- pos[0] = FXARGB_B(color);
- pos[1] = FXARGB_G(color);
- 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,
- bool bFlipX,
- int clip_left,
- int clip_width) const {
- if (!m_pBuffer) {
- return;
- }
- int src_Bpp = m_bpp / 8;
- uint8_t* scanline = m_pBuffer + line * m_Pitch;
- if (src_Bpp == 0) {
- for (int i = 0; i < clip_width; i++) {
- 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;
- dest_scan[i] = (scanline[src_x / 8] & (1 << (7 - src_x % 8))) ? 255 : 0;
- }
- } else if (src_Bpp == 1) {
- for (int i = 0; i < clip_width; i++) {
- 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.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.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 {
- for (int i = 0; i < clip_width; i++) {
- uint32_t dest_x = clip_left + i;
- uint32_t src_x =
- bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp
- : (dest_x * m_Width / dest_width) * src_Bpp;
- src_x %= m_Width * src_Bpp;
- int dest_pos = i * src_Bpp;
- for (int b = 0; b < src_Bpp; b++) {
- dest_scan[dest_pos + b] = scanline[src_x + b];
- }
- }
- }
-}
-
-// TODO(weili): Split this function into two for handling CMYK and RGB
-// colors separately.
-bool CFX_DIBitmap::ConvertColorScale(uint32_t forecolor, uint32_t backcolor) {
- ASSERT(!IsAlphaMask());
- if (!m_pBuffer || IsAlphaMask()) {
- return false;
- }
- // Values used for CMYK colors.
- int fc = 0;
- int fm = 0;
- int fy = 0;
- int fk = 0;
- int bc = 0;
- int bm = 0;
- int by = 0;
- int bk = 0;
- // Values used for RGB colors.
- int fr = 0;
- int fg = 0;
- int fb = 0;
- int br = 0;
- int bg = 0;
- int bb = 0;
- bool isCmykImage = IsCmykImage();
- if (isCmykImage) {
- fc = FXSYS_GetCValue(forecolor);
- fm = FXSYS_GetMValue(forecolor);
- fy = FXSYS_GetYValue(forecolor);
- fk = FXSYS_GetKValue(forecolor);
- bc = FXSYS_GetCValue(backcolor);
- bm = FXSYS_GetMValue(backcolor);
- by = FXSYS_GetYValue(backcolor);
- bk = FXSYS_GetKValue(backcolor);
- } else {
- fr = FXSYS_GetRValue(forecolor);
- fg = FXSYS_GetGValue(forecolor);
- fb = FXSYS_GetBValue(forecolor);
- br = FXSYS_GetRValue(backcolor);
- bg = FXSYS_GetGValue(backcolor);
- bb = FXSYS_GetBValue(backcolor);
- }
- if (m_bpp <= 8) {
- if (isCmykImage) {
- if (forecolor == 0xff && backcolor == 0 && !m_pPalette) {
- return true;
- }
- } 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.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.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.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;
- AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
- r, g, b);
- *scanline++ = 0;
- *scanline++ = 0;
- *scanline++ = 0;
- *scanline++ = 255 - FXRGB2GRAY(r, g, b);
- }
- }
- return true;
- }
- } else if (forecolor == 0 && backcolor == 0xffffff) {
- for (int row = 0; row < m_Height; row++) {
- uint8_t* scanline = m_pBuffer + row * m_Pitch;
- int gap = m_bpp / 8 - 2;
- for (int col = 0; col < m_Width; col++) {
- int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
- *scanline++ = gray;
- *scanline++ = gray;
- *scanline = gray;
- scanline += gap;
- }
- }
- return true;
- }
- if (isCmykImage) {
- 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;
- AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
- r, g, b);
- int gray = 255 - FXRGB2GRAY(r, g, b);
- *scanline++ = bc + (fc - bc) * gray / 255;
- *scanline++ = bm + (fm - bm) * gray / 255;
- *scanline++ = by + (fy - by) * gray / 255;
- *scanline++ = bk + (fk - bk) * gray / 255;
- }
- }
- } else {
- for (int row = 0; row < m_Height; row++) {
- uint8_t* scanline = m_pBuffer + row * m_Pitch;
- int gap = m_bpp / 8 - 2;
- for (int col = 0; col < m_Width; col++) {
- int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
- *scanline++ = bb + (fb - bb) * gray / 255;
- *scanline++ = bg + (fg - bg) * gray / 255;
- *scanline = br + (fr - br) * gray / 255;
- scanline += gap;
- }
- }
- }
- return true;
-}
-
-CFX_DIBExtractor::CFX_DIBExtractor(const CFX_RetainPtr<CFX_DIBSource>& pSrc) {
- if (pSrc->GetBuffer()) {
- CFX_RetainPtr<CFX_DIBSource> pOldSrc(pSrc);
- m_pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
- if (!m_pBitmap->Create(pOldSrc->GetWidth(), pOldSrc->GetHeight(),
- pOldSrc->GetFormat(), pOldSrc->GetBuffer())) {
- m_pBitmap.Reset();
- return;
- }
- m_pBitmap->SetPalette(pOldSrc->GetPalette());
- m_pBitmap->SetAlphaMask(pOldSrc->m_pAlphaMask);
- } else {
- m_pBitmap = pSrc->Clone();
- }
-}
-
-CFX_DIBExtractor::~CFX_DIBExtractor() {}
-
CFX_BitmapStorer::CFX_BitmapStorer() {
}
diff --git a/core/fxge/fx_dib.h b/core/fxge/fx_dib.h
index 2a111ac05f..3be4fc6e3b 100644
--- a/core/fxge/fx_dib.h
+++ b/core/fxge/fx_dib.h
@@ -118,17 +118,6 @@ bool ConvertBuffer(FXDIB_Format dest_format,
int src_top,
std::unique_ptr<uint32_t, FxFreeDeleter>* pal);
-class CFX_DIBExtractor {
- public:
- explicit CFX_DIBExtractor(const CFX_RetainPtr<CFX_DIBSource>& pSrc);
- ~CFX_DIBExtractor();
-
- CFX_RetainPtr<CFX_DIBitmap> GetBitmap() { return m_pBitmap; }
-
- private:
- CFX_RetainPtr<CFX_DIBitmap> m_pBitmap;
-};
-
class IFX_ScanlineComposer {
public:
virtual ~IFX_ScanlineComposer() {}
diff --git a/core/fxge/win32/cfx_psrenderer.cpp b/core/fxge/win32/cfx_psrenderer.cpp
index 5350c383b4..5dd9079c36 100644
--- a/core/fxge/win32/cfx_psrenderer.cpp
+++ b/core/fxge/win32/cfx_psrenderer.cpp
@@ -14,6 +14,7 @@
#include "core/fxge/cfx_fontcache.h"
#include "core/fxge/cfx_pathdata.h"
#include "core/fxge/cfx_renderdevice.h"
+#include "core/fxge/dib/cfx_dibextractor.h"
#include "core/fxge/ge/fx_text_int.h"
#include "core/fxge/win32/cpsoutput.h"
#include "third_party/base/ptr_util.h"
diff --git a/core/fxge/win32/fx_win32_device.cpp b/core/fxge/win32/fx_win32_device.cpp
index 140a5b07d5..3b56477e7e 100644
--- a/core/fxge/win32/fx_win32_device.cpp
+++ b/core/fxge/win32/fx_win32_device.cpp
@@ -15,6 +15,7 @@
#include "core/fxcrt/fx_memory.h"
#include "core/fxcrt/fx_system.h"
#include "core/fxge/cfx_windowsdevice.h"
+#include "core/fxge/dib/cfx_dibextractor.h"
#include "core/fxge/dib/dib_int.h"
#include "core/fxge/fx_font.h"
#include "core/fxge/fx_freetype.h"
diff --git a/core/fxge/win32/fx_win32_print.cpp b/core/fxge/win32/fx_win32_print.cpp
index 6d96243655..26ac6605fb 100644
--- a/core/fxge/win32/fx_win32_print.cpp
+++ b/core/fxge/win32/fx_win32_print.cpp
@@ -12,6 +12,7 @@
#include "core/fxcrt/fx_system.h"
#include "core/fxge/cfx_windowsdevice.h"
+#include "core/fxge/dib/cfx_dibextractor.h"
#include "core/fxge/dib/dib_int.h"
#include "core/fxge/fx_freetype.h"
#include "core/fxge/ge/fx_text_int.h"
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 15:29:45 +0000