| // Copyright 2017 The PDFium Authors |
| // 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 <stdint.h> |
| #include <string.h> |
| |
| #include <limits> |
| #include <memory> |
| #include <utility> |
| |
| #include "build/build_config.h" |
| #include "core/fxcrt/data_vector.h" |
| #include "core/fxcrt/fx_coordinates.h" |
| #include "core/fxcrt/fx_safe_types.h" |
| #include "core/fxcrt/span_util.h" |
| #include "core/fxge/calculate_pitch.h" |
| #include "core/fxge/cfx_cliprgn.h" |
| #include "core/fxge/cfx_defaultrenderdevice.h" |
| #include "core/fxge/dib/cfx_scanlinecompositor.h" |
| #include "third_party/base/check.h" |
| #include "third_party/base/check_op.h" |
| #include "third_party/base/notreached.h" |
| #include "third_party/base/numerics/safe_conversions.h" |
| |
| CFX_DIBitmap::CFX_DIBitmap() = default; |
| |
| bool CFX_DIBitmap::Create(int width, int height, FXDIB_Format format) { |
| return Create(width, height, format, nullptr, 0); |
| } |
| |
| bool CFX_DIBitmap::Create(int width, |
| int height, |
| FXDIB_Format format, |
| uint8_t* pBuffer, |
| uint32_t pitch) { |
| m_pBuffer = nullptr; |
| m_Format = format; |
| m_Width = 0; |
| m_Height = 0; |
| m_Pitch = 0; |
| |
| absl::optional<PitchAndSize> pitch_size = |
| CalculatePitchAndSize(width, height, format, pitch); |
| if (!pitch_size.has_value()) |
| return false; |
| |
| if (pBuffer) { |
| m_pBuffer.Reset(pBuffer); |
| } else { |
| FX_SAFE_SIZE_T safe_buffer_size = pitch_size.value().size; |
| safe_buffer_size += 4; |
| if (!safe_buffer_size.IsValid()) |
| return false; |
| |
| m_pBuffer = std::unique_ptr<uint8_t, FxFreeDeleter>( |
| FX_TryAlloc(uint8_t, safe_buffer_size.ValueOrDie())); |
| if (!m_pBuffer) |
| return false; |
| } |
| m_Width = width; |
| m_Height = height; |
| m_Pitch = pitch_size.value().pitch; |
| return true; |
| } |
| |
| bool CFX_DIBitmap::Copy(const RetainPtr<CFX_DIBBase>& pSrc) { |
| if (m_pBuffer) |
| return false; |
| |
| if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) |
| return false; |
| |
| SetPalette(pSrc->GetPaletteSpan()); |
| for (int row = 0; row < pSrc->GetHeight(); row++) { |
| memcpy(m_pBuffer.Get() + row * m_Pitch, pSrc->GetScanline(row).data(), |
| m_Pitch); |
| } |
| return true; |
| } |
| |
| CFX_DIBitmap::~CFX_DIBitmap() = default; |
| |
| pdfium::span<const uint8_t> CFX_DIBitmap::GetBuffer() const { |
| if (!m_pBuffer) |
| return pdfium::span<const uint8_t>(); |
| |
| return {m_pBuffer.Get(), m_Height * m_Pitch}; |
| } |
| |
| pdfium::span<const uint8_t> CFX_DIBitmap::GetScanline(int line) const { |
| auto buffer_span = GetBuffer(); |
| if (buffer_span.empty()) |
| return pdfium::span<const uint8_t>(); |
| |
| return buffer_span.subspan(line * m_Pitch, m_Pitch); |
| } |
| |
| size_t CFX_DIBitmap::GetEstimatedImageMemoryBurden() const { |
| size_t result = CFX_DIBBase::GetEstimatedImageMemoryBurden(); |
| if (!GetBuffer().empty()) { |
| int height = GetHeight(); |
| CHECK(pdfium::base::IsValueInRangeForNumericType<size_t>(height)); |
| result += static_cast<size_t>(height) * GetPitch(); |
| } |
| return result; |
| } |
| |
| #if BUILDFLAG(IS_WIN) || defined(_SKIA_SUPPORT_) |
| RetainPtr<const CFX_DIBitmap> CFX_DIBitmap::RealizeIfNeeded() const { |
| if (GetBuffer().empty()) { |
| return Realize(); |
| } |
| return pdfium::WrapRetain(this); |
| } |
| #endif |
| |
| void CFX_DIBitmap::TakeOver(RetainPtr<CFX_DIBitmap>&& pSrcBitmap) { |
| m_pBuffer = std::move(pSrcBitmap->m_pBuffer); |
| m_palette = std::move(pSrcBitmap->m_palette); |
| pSrcBitmap->m_pBuffer = nullptr; |
| m_Format = pSrcBitmap->m_Format; |
| 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; |
| |
| uint8_t* pBuffer = m_pBuffer.Get(); |
| switch (GetFormat()) { |
| case FXDIB_Format::k1bppMask: |
| memset(pBuffer, (color & 0xff000000) ? 0xff : 0, m_Pitch * m_Height); |
| break; |
| case FXDIB_Format::k1bppRgb: { |
| int index = FindPalette(color); |
| memset(pBuffer, index ? 0xff : 0, m_Pitch * m_Height); |
| break; |
| } |
| case FXDIB_Format::k8bppMask: |
| memset(pBuffer, color >> 24, m_Pitch * m_Height); |
| break; |
| case FXDIB_Format::k8bppRgb: { |
| int index = FindPalette(color); |
| memset(pBuffer, index, m_Pitch * m_Height); |
| break; |
| } |
| case FXDIB_Format::kRgb: { |
| int a; |
| int r; |
| int g; |
| int b; |
| std::tie(a, r, g, b) = ArgbDecode(color); |
| if (r == g && g == b) { |
| memset(pBuffer, r, m_Pitch * m_Height); |
| } else { |
| int byte_pos = 0; |
| for (int col = 0; col < m_Width; col++) { |
| pBuffer[byte_pos++] = b; |
| pBuffer[byte_pos++] = g; |
| pBuffer[byte_pos++] = r; |
| } |
| for (int row = 1; row < m_Height; row++) { |
| memcpy(pBuffer + row * m_Pitch, pBuffer, m_Pitch); |
| } |
| } |
| break; |
| } |
| case FXDIB_Format::kRgb32: |
| case FXDIB_Format::kArgb: { |
| if (CFX_DefaultRenderDevice::UseSkiaRenderer() && |
| FXDIB_Format::kRgb32 == GetFormat()) { |
| // TODO(crbug.com/pdfium/2016): This is not reliable because alpha may |
| // be modified outside of this operation. |
| color |= 0xFF000000; |
| } |
| for (int i = 0; i < m_Width; i++) |
| reinterpret_cast<uint32_t*>(pBuffer)[i] = color; |
| for (int row = 1; row < m_Height; row++) |
| memcpy(pBuffer + row * m_Pitch, pBuffer, m_Pitch); |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| bool CFX_DIBitmap::TransferBitmap(int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top) { |
| if (!m_pBuffer) |
| return false; |
| |
| if (!GetOverlapRect(dest_left, dest_top, width, height, |
| pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, |
| src_top, nullptr)) { |
| return true; |
| } |
| |
| FXDIB_Format dest_format = GetFormat(); |
| FXDIB_Format src_format = pSrcBitmap->GetFormat(); |
| if (dest_format != src_format) { |
| return TransferWithUnequalFormats(dest_format, dest_left, dest_top, width, |
| height, pSrcBitmap, src_left, src_top); |
| } |
| |
| if (GetBPP() != 1) { |
| TransferWithMultipleBPP(dest_left, dest_top, width, height, pSrcBitmap, |
| src_left, src_top); |
| return true; |
| } |
| |
| TransferEqualFormatsOneBPP(dest_left, dest_top, width, height, pSrcBitmap, |
| src_left, src_top); |
| return true; |
| } |
| |
| bool CFX_DIBitmap::TransferWithUnequalFormats( |
| FXDIB_Format dest_format, |
| int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top) { |
| if (HasPalette()) |
| return false; |
| |
| if (GetBppFromFormat(m_Format) == 8) |
| dest_format = FXDIB_Format::k8bppMask; |
| |
| FX_SAFE_UINT32 offset = dest_left; |
| offset *= GetBPP(); |
| offset /= 8; |
| if (!offset.IsValid()) |
| return false; |
| |
| pdfium::span<uint8_t> dest_buf = GetWritableBuffer().subspan( |
| dest_top * m_Pitch + static_cast<uint32_t>(offset.ValueOrDie())); |
| DataVector<uint32_t> d_plt; |
| return ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, |
| pSrcBitmap, src_left, src_top, &d_plt); |
| } |
| |
| void CFX_DIBitmap::TransferWithMultipleBPP( |
| int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top) { |
| int Bpp = GetBPP() / 8; |
| for (int row = 0; row < height; ++row) { |
| uint8_t* dest_scan = |
| m_pBuffer.Get() + (dest_top + row) * m_Pitch + dest_left * Bpp; |
| const uint8_t* src_scan = |
| pSrcBitmap->GetScanline(src_top + row).subspan(src_left * Bpp).data(); |
| memcpy(dest_scan, src_scan, width * Bpp); |
| } |
| } |
| |
| void CFX_DIBitmap::TransferEqualFormatsOneBPP( |
| int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top) { |
| for (int row = 0; row < height; ++row) { |
| uint8_t* dest_scan = m_pBuffer.Get() + (dest_top + row) * m_Pitch; |
| const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row).data(); |
| for (int col = 0; col < width; ++col) { |
| int src_idx = src_left + col; |
| int dest_idx = dest_left + col; |
| if (src_scan[(src_idx) / 8] & (1 << (7 - (src_idx) % 8))) |
| dest_scan[(dest_idx) / 8] |= 1 << (7 - (dest_idx) % 8); |
| else |
| dest_scan[(dest_idx) / 8] &= ~(1 << (7 - (dest_idx) % 8)); |
| } |
| } |
| } |
| |
| bool CFX_DIBitmap::SetChannelFromBitmap( |
| Channel destChannel, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap) { |
| if (!m_pBuffer) |
| return false; |
| |
| RetainPtr<CFX_DIBBase> pSrcClone = pSrcBitmap; |
| if (!pSrcBitmap->IsAlphaFormat() && !pSrcBitmap->IsMaskFormat()) |
| return false; |
| |
| if (pSrcBitmap->GetBPP() == 1) { |
| pSrcClone = pSrcBitmap->ConvertTo(FXDIB_Format::k8bppMask); |
| if (!pSrcClone) |
| return false; |
| } |
| const int srcOffset = pSrcBitmap->GetFormat() == FXDIB_Format::kArgb ? 3 : 0; |
| int destOffset = 0; |
| if (destChannel == Channel::kAlpha) { |
| if (IsMaskFormat()) { |
| if (!ConvertFormat(FXDIB_Format::k8bppMask)) |
| return false; |
| } else { |
| if (!ConvertFormat(FXDIB_Format::kArgb)) |
| return false; |
| |
| destOffset = 3; |
| } |
| } else { |
| DCHECK_EQ(destChannel, Channel::kRed); |
| if (IsMaskFormat()) |
| return false; |
| |
| if (GetBPP() < 24) { |
| if (IsAlphaFormat()) { |
| if (!ConvertFormat(FXDIB_Format::kArgb)) |
| return false; |
| } else { |
| if (!ConvertFormat(kPlatformRGBFormat)) |
| return false; |
| } |
| } |
| destOffset = 2; |
| } |
| if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) { |
| RetainPtr<CFX_DIBitmap> pSrcMatched = pSrcClone->StretchTo( |
| m_Width, m_Height, FXDIB_ResampleOptions(), nullptr); |
| if (!pSrcMatched) |
| return false; |
| |
| pSrcClone = pSrcMatched; |
| } |
| RetainPtr<CFX_DIBitmap> pDst(this); |
| int srcBytes = pSrcClone->GetBPP() / 8; |
| int destBytes = pDst->GetBPP() / 8; |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* dest_pos = |
| pDst->GetWritableScanline(row).subspan(destOffset).data(); |
| const uint8_t* src_pos = |
| pSrcClone->GetScanline(row).subspan(srcOffset).data(); |
| for (int col = 0; col < m_Width; col++) { |
| *dest_pos = *src_pos; |
| dest_pos += destBytes; |
| src_pos += srcBytes; |
| } |
| } |
| return true; |
| } |
| |
| bool CFX_DIBitmap::SetAlphaFromBitmap( |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap) { |
| return SetChannelFromBitmap(Channel::kAlpha, pSrcBitmap); |
| } |
| |
| bool CFX_DIBitmap::SetRedFromBitmap(const RetainPtr<CFX_DIBBase>& pSrcBitmap) { |
| return SetChannelFromBitmap(Channel::kRed, pSrcBitmap); |
| } |
| |
| bool CFX_DIBitmap::SetUniformOpaqueAlpha() { |
| if (!m_pBuffer) |
| return false; |
| |
| if (IsMaskFormat()) { |
| if (!ConvertFormat(FXDIB_Format::k8bppMask)) |
| return false; |
| } else { |
| if (!ConvertFormat(FXDIB_Format::kArgb)) |
| return false; |
| } |
| const int Bpp = GetBPP() / 8; |
| if (Bpp == 1) { |
| memset(m_pBuffer.Get(), 0xff, m_Height * m_Pitch); |
| return true; |
| } |
| const int destOffset = GetFormat() == FXDIB_Format::kArgb ? 3 : 0; |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* scan_line = m_pBuffer.Get() + row * m_Pitch + destOffset; |
| for (int col = 0; col < m_Width; col++) { |
| *scan_line = 0xff; |
| scan_line += Bpp; |
| } |
| } |
| return true; |
| } |
| |
| bool CFX_DIBitmap::MultiplyAlpha(const RetainPtr<CFX_DIBBase>& pSrcBitmap) { |
| CHECK(pSrcBitmap->IsMaskFormat()); |
| |
| if (!m_pBuffer) { |
| return false; |
| } |
| |
| if (IsOpaqueImage()) |
| return SetAlphaFromBitmap(pSrcBitmap); |
| |
| RetainPtr<CFX_DIBitmap> pSrcClone = pSrcBitmap.As<CFX_DIBitmap>(); |
| if (pSrcBitmap->GetWidth() != m_Width || |
| pSrcBitmap->GetHeight() != m_Height) { |
| pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height, |
| FXDIB_ResampleOptions(), nullptr); |
| if (!pSrcClone) |
| return false; |
| } |
| if (IsMaskFormat()) { |
| if (!ConvertFormat(FXDIB_Format::k8bppMask)) |
| return false; |
| |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* dest_scan = m_pBuffer.Get() + m_Pitch * row; |
| uint8_t* src_scan = pSrcClone->m_pBuffer.Get() + 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++; |
| } |
| } |
| } |
| return true; |
| } |
| |
| DCHECK_EQ(GetFormat(), FXDIB_Format::kArgb); |
| if (pSrcClone->GetBPP() == 1) |
| return false; |
| |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* dest_scan = m_pBuffer.Get() + m_Pitch * row + 3; |
| uint8_t* src_scan = pSrcClone->m_pBuffer.Get() + pSrcClone->m_Pitch * row; |
| for (int col = 0; col < m_Width; col++) { |
| *dest_scan = (*dest_scan) * src_scan[col] / 255; |
| dest_scan += 4; |
| } |
| } |
| return true; |
| } |
| |
| bool CFX_DIBitmap::MultiplyAlpha(int alpha) { |
| if (!m_pBuffer) |
| return false; |
| |
| switch (GetFormat()) { |
| case FXDIB_Format::k1bppMask: |
| if (!ConvertFormat(FXDIB_Format::k8bppMask)) { |
| return false; |
| } |
| MultiplyAlpha(alpha); |
| break; |
| case FXDIB_Format::k8bppMask: { |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* scan_line = m_pBuffer.Get() + row * m_Pitch; |
| for (int col = 0; col < m_Width; col++) { |
| scan_line[col] = scan_line[col] * alpha / 255; |
| } |
| } |
| break; |
| } |
| case FXDIB_Format::kArgb: { |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* scan_line = m_pBuffer.Get() + row * m_Pitch + 3; |
| for (int col = 0; col < m_Width; col++) { |
| *scan_line = (*scan_line) * alpha / 255; |
| scan_line += 4; |
| } |
| } |
| break; |
| } |
| default: |
| DCHECK(!IsAlphaFormat()); |
| if (!ConvertFormat(FXDIB_Format::kArgb)) { |
| return false; |
| } |
| MultiplyAlpha(alpha); |
| break; |
| } |
| return true; |
| } |
| |
| #if defined(_SKIA_SUPPORT_) |
| uint32_t CFX_DIBitmap::GetPixel(int x, int y) const { |
| if (!m_pBuffer) |
| return 0; |
| |
| FX_SAFE_UINT32 offset = x; |
| offset *= GetBPP(); |
| offset /= 8; |
| if (!offset.IsValid()) |
| return 0; |
| |
| uint8_t* pos = m_pBuffer.Get() + y * m_Pitch + offset.ValueOrDie(); |
| switch (GetFormat()) { |
| case FXDIB_Format::k1bppMask: { |
| if ((*pos) & (1 << (7 - x % 8))) { |
| return 0xff000000; |
| } |
| return 0; |
| } |
| case FXDIB_Format::k1bppRgb: { |
| if ((*pos) & (1 << (7 - x % 8))) { |
| return HasPalette() ? GetPaletteSpan()[1] : 0xffffffff; |
| } |
| return HasPalette() ? GetPaletteSpan()[0] : 0xff000000; |
| } |
| case FXDIB_Format::k8bppMask: |
| return (*pos) << 24; |
| case FXDIB_Format::k8bppRgb: |
| return HasPalette() ? GetPaletteSpan()[*pos] |
| : ArgbEncode(0xff, *pos, *pos, *pos); |
| case FXDIB_Format::kRgb: |
| case FXDIB_Format::kRgb32: |
| return FXARGB_GETDIB(pos) | 0xff000000; |
| case FXDIB_Format::kArgb: |
| 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; |
| |
| FX_SAFE_UINT32 offset = x; |
| offset *= GetBPP(); |
| offset /= 8; |
| if (!offset.IsValid()) |
| return; |
| |
| uint8_t* pos = m_pBuffer.Get() + y * m_Pitch + offset.ValueOrDie(); |
| switch (GetFormat()) { |
| case FXDIB_Format::k1bppMask: |
| if (color >> 24) { |
| *pos |= 1 << (7 - x % 8); |
| } else { |
| *pos &= ~(1 << (7 - x % 8)); |
| } |
| break; |
| case FXDIB_Format::k1bppRgb: |
| if (HasPalette()) { |
| if (color == GetPaletteSpan()[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_Format::k8bppMask: |
| *pos = (uint8_t)(color >> 24); |
| break; |
| case FXDIB_Format::k8bppRgb: { |
| if (HasPalette()) { |
| pdfium::span<const uint32_t> palette = GetPaletteSpan(); |
| for (int i = 0; i < 256; i++) { |
| if (palette[i] == color) { |
| *pos = (uint8_t)i; |
| return; |
| } |
| } |
| *pos = 0; |
| } else { |
| *pos = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color)); |
| } |
| break; |
| } |
| case FXDIB_Format::kRgb: |
| case FXDIB_Format::kRgb32: { |
| 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_Format::kArgb: |
| FXARGB_SETDIB(pos, color); |
| break; |
| default: |
| break; |
| } |
| } |
| #endif // defined(_SKIA_SUPPORT_) |
| |
| void CFX_DIBitmap::ConvertBGRColorScale(uint32_t forecolor, |
| uint32_t backcolor) { |
| int fr = FXSYS_GetRValue(forecolor); |
| int fg = FXSYS_GetGValue(forecolor); |
| int fb = FXSYS_GetBValue(forecolor); |
| int br = FXSYS_GetRValue(backcolor); |
| int bg = FXSYS_GetGValue(backcolor); |
| int bb = FXSYS_GetBValue(backcolor); |
| if (GetBppFromFormat(m_Format) <= 8) { |
| if (forecolor == 0 && backcolor == 0xffffff && !HasPalette()) |
| return; |
| |
| BuildPalette(); |
| int size = 1 << GetBppFromFormat(m_Format); |
| for (int i = 0; i < size; ++i) { |
| int gray = FXRGB2GRAY(FXARGB_R(m_palette[i]), FXARGB_G(m_palette[i]), |
| FXARGB_B(m_palette[i])); |
| m_palette[i] = |
| ArgbEncode(0xff, br + (fr - br) * gray / 255, |
| bg + (fg - bg) * gray / 255, bb + (fb - bb) * gray / 255); |
| } |
| return; |
| } |
| if (forecolor == 0 && backcolor == 0xffffff) { |
| for (int row = 0; row < m_Height; ++row) { |
| uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch; |
| int gap = GetBppFromFormat(m_Format) / 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; |
| } |
| for (int row = 0; row < m_Height; ++row) { |
| uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch; |
| int gap = GetBppFromFormat(m_Format) / 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; |
| } |
| } |
| } |
| |
| bool CFX_DIBitmap::ConvertColorScale(uint32_t forecolor, uint32_t backcolor) { |
| if (!m_pBuffer || IsMaskFormat()) |
| return false; |
| |
| ConvertBGRColorScale(forecolor, backcolor); |
| return true; |
| } |
| |
| // static |
| absl::optional<CFX_DIBitmap::PitchAndSize> CFX_DIBitmap::CalculatePitchAndSize( |
| int width, |
| int height, |
| FXDIB_Format format, |
| uint32_t pitch) { |
| if (width <= 0 || height <= 0) |
| return absl::nullopt; |
| |
| int bpp = GetBppFromFormat(format); |
| if (!bpp) |
| return absl::nullopt; |
| |
| uint32_t actual_pitch = pitch; |
| if (actual_pitch == 0) { |
| absl::optional<uint32_t> pitch32 = fxge::CalculatePitch32(bpp, width); |
| if (!pitch32.has_value()) { |
| return absl::nullopt; |
| } |
| |
| actual_pitch = pitch32.value(); |
| } |
| |
| FX_SAFE_UINT32 safe_size = actual_pitch; |
| safe_size *= height; |
| if (!safe_size.IsValid()) |
| return absl::nullopt; |
| |
| return PitchAndSize{actual_pitch, safe_size.ValueOrDie()}; |
| } |
| |
| bool CFX_DIBitmap::CompositeBitmap(int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top, |
| BlendMode blend_type, |
| const CFX_ClipRgn* pClipRgn, |
| bool bRgbByteOrder) { |
| // Should have called CompositeMask(). |
| CHECK(!pSrcBitmap->IsMaskFormat()); |
| |
| if (!m_pBuffer) |
| return false; |
| |
| if (GetBppFromFormat(m_Format) < 8) |
| return false; |
| |
| if (!GetOverlapRect(dest_left, dest_top, width, height, |
| pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, |
| src_top, pClipRgn)) { |
| return true; |
| } |
| |
| RetainPtr<CFX_DIBitmap> pClipMask; |
| FX_RECT clip_box; |
| if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::kRectI) { |
| pClipMask = pClipRgn->GetMask(); |
| clip_box = pClipRgn->GetBox(); |
| } |
| CFX_ScanlineCompositor compositor; |
| if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), |
| pSrcBitmap->GetPaletteSpan(), 0, blend_type, |
| pClipMask != nullptr, bRgbByteOrder)) { |
| return false; |
| } |
| const int dest_Bpp = GetBppFromFormat(m_Format) / 8; |
| const int src_Bpp = pSrcBitmap->GetBPP() / 8; |
| const bool bRgb = src_Bpp > 1; |
| if (!bRgb && !pSrcBitmap->HasPalette()) |
| return false; |
| |
| for (int row = 0; row < height; row++) { |
| pdfium::span<uint8_t> dest_scan = |
| GetWritableScanline(dest_top + row).subspan(dest_left * dest_Bpp); |
| pdfium::span<const uint8_t> src_scan = |
| pSrcBitmap->GetScanline(src_top + row).subspan(src_left * src_Bpp); |
| pdfium::span<const uint8_t> clip_scan; |
| if (pClipMask) { |
| clip_scan = pClipMask->GetWritableScanline(dest_top + row - clip_box.top) |
| .subspan(dest_left - clip_box.left); |
| } |
| if (bRgb) { |
| compositor.CompositeRgbBitmapLine(dest_scan, src_scan, width, clip_scan); |
| } else { |
| compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width, |
| clip_scan); |
| } |
| } |
| return true; |
| } |
| |
| bool CFX_DIBitmap::CompositeMask(int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pMask, |
| uint32_t color, |
| int src_left, |
| int src_top, |
| BlendMode blend_type, |
| const CFX_ClipRgn* pClipRgn, |
| bool bRgbByteOrder) { |
| // Should have called CompositeBitmap(). |
| CHECK(pMask->IsMaskFormat()); |
| |
| if (!m_pBuffer) |
| return false; |
| |
| if (GetBppFromFormat(m_Format) < 8) |
| return false; |
| |
| if (!GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), |
| pMask->GetHeight(), src_left, src_top, pClipRgn)) { |
| return true; |
| } |
| |
| int src_alpha = FXARGB_A(color); |
| if (src_alpha == 0) |
| return true; |
| |
| RetainPtr<CFX_DIBitmap> pClipMask; |
| FX_RECT clip_box; |
| if (pClipRgn && pClipRgn->GetType() != CFX_ClipRgn::kRectI) { |
| 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(), {}, color, blend_type, |
| pClipMask != nullptr, bRgbByteOrder)) { |
| return false; |
| } |
| for (int row = 0; row < height; row++) { |
| pdfium::span<uint8_t> dest_scan = |
| GetWritableScanline(dest_top + row).subspan(dest_left * Bpp); |
| pdfium::span<const uint8_t> src_scan = pMask->GetScanline(src_top + row); |
| pdfium::span<const uint8_t> clip_scan; |
| if (pClipMask) { |
| clip_scan = pClipMask->GetScanline(dest_top + row - clip_box.top) |
| .subspan(dest_left - clip_box.left); |
| } |
| if (src_bpp == 1) { |
| compositor.CompositeBitMaskLine(dest_scan, src_scan, src_left, width, |
| clip_scan); |
| } else { |
| compositor.CompositeByteMaskLine(dest_scan, src_scan.subspan(src_left), |
| width, clip_scan); |
| } |
| } |
| return true; |
| } |
| |
| void CFX_DIBitmap::CompositeOneBPPMask(int dest_left, |
| int dest_top, |
| int width, |
| int height, |
| const RetainPtr<CFX_DIBBase>& pSrcBitmap, |
| int src_left, |
| int src_top) { |
| if (GetBPP() != 1) { |
| return; |
| } |
| |
| if (!GetOverlapRect(dest_left, dest_top, width, height, |
| pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, |
| src_top, nullptr)) { |
| return; |
| } |
| |
| for (int row = 0; row < height; ++row) { |
| uint8_t* dest_scan = m_pBuffer.Get() + (dest_top + row) * m_Pitch; |
| const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row).data(); |
| for (int col = 0; col < width; ++col) { |
| int src_idx = src_left + col; |
| int dest_idx = dest_left + col; |
| if (src_scan[src_idx / 8] & (1 << (7 - src_idx % 8))) { |
| dest_scan[dest_idx / 8] |= 1 << (7 - dest_idx % 8); |
| } |
| } |
| } |
| } |
| |
| bool CFX_DIBitmap::CompositeRect(int left, |
| int top, |
| int width, |
| int height, |
| uint32_t color) { |
| if (!m_pBuffer) |
| return false; |
| |
| int src_alpha = 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 = color; |
| uint8_t* color_p = reinterpret_cast<uint8_t*>(&dst_color); |
| if (GetBppFromFormat(m_Format) == 8) { |
| uint8_t gray = IsMaskFormat() ? 255 |
| : (uint8_t)FXRGB2GRAY((int)color_p[2], |
| color_p[1], color_p[0]); |
| for (int row = rect.top; row < rect.bottom; row++) { |
| uint8_t* dest_scan = m_pBuffer.Get() + row * m_Pitch + rect.left; |
| if (src_alpha == 255) { |
| 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 (GetBppFromFormat(m_Format) == 1) { |
| 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 (HasPalette()) { |
| for (int i = 0; i < 2; i++) { |
| if (GetPaletteSpan()[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 = |
| GetWritableScanline(row).subspan(rect.left / 8).data(); |
| uint8_t* dest_scan_top_r = |
| GetWritableScanline(row).subspan(rect.right / 8).data(); |
| 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) { |
| 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; |
| } |
| |
| CHECK_GE(GetBppFromFormat(m_Format), 24); |
| color_p[3] = static_cast<uint8_t>(src_alpha); |
| int Bpp = GetBppFromFormat(m_Format) / 8; |
| const bool bAlpha = IsAlphaFormat(); |
| if (bAlpha) { |
| // Other formats with alpha have already been handled above. |
| DCHECK_EQ(GetFormat(), FXDIB_Format::kArgb); |
| } |
| if (src_alpha == 255) { |
| for (int row = rect.top; row < rect.bottom; row++) { |
| uint8_t* dest_scan = m_pBuffer.Get() + row * m_Pitch + rect.left * Bpp; |
| if (Bpp == 4) { |
| uint32_t* scan = reinterpret_cast<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.Get() + row * m_Pitch + rect.left * Bpp; |
| if (bAlpha) { |
| for (int col = 0; col < width; col++) { |
| uint8_t back_alpha = dest_scan[3]; |
| if (back_alpha == 0) { |
| FXARGB_SETDIB(dest_scan, ArgbEncode(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 { |
| 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) { |
| DCHECK(dest_format == FXDIB_Format::k8bppMask || |
| dest_format == FXDIB_Format::kArgb || |
| dest_format == FXDIB_Format::kRgb32 || |
| dest_format == FXDIB_Format::kRgb); |
| |
| if (dest_format == m_Format) |
| return true; |
| |
| if (dest_format == FXDIB_Format::k8bppMask && |
| m_Format == FXDIB_Format::k8bppRgb && !HasPalette()) { |
| m_Format = FXDIB_Format::k8bppMask; |
| return true; |
| } |
| if (dest_format == FXDIB_Format::kArgb && m_Format == FXDIB_Format::kRgb32) { |
| m_Format = FXDIB_Format::kArgb; |
| for (int row = 0; row < m_Height; row++) { |
| uint8_t* scanline = m_pBuffer.Get() + row * m_Pitch + 3; |
| for (int col = 0; col < m_Width; col++) { |
| *scanline = 0xff; |
| scanline += 4; |
| } |
| } |
| return true; |
| } |
| int dest_bpp = GetBppFromFormat(dest_format); |
| int dest_pitch = fxge::CalculatePitch32OrDie(dest_bpp, m_Width); |
| const size_t dest_buf_size = dest_pitch * m_Height + 4; |
| std::unique_ptr<uint8_t, FxFreeDeleter> dest_buf( |
| FX_TryAlloc(uint8_t, dest_buf_size)); |
| if (!dest_buf) |
| return false; |
| |
| if (dest_format == FXDIB_Format::kArgb) { |
| memset(dest_buf.get(), 0xff, dest_buf_size); |
| } |
| RetainPtr<CFX_DIBBase> holder(this); |
| DataVector<uint32_t> pal_8bpp; |
| if (!ConvertBuffer(dest_format, {dest_buf.get(), dest_buf_size}, dest_pitch, |
| m_Width, m_Height, holder, 0, 0, &pal_8bpp)) { |
| return false; |
| } |
| |
| m_palette = std::move(pal_8bpp); |
| m_pBuffer = std::move(dest_buf); |
| m_Format = dest_format; |
| m_Pitch = dest_pitch; |
| return true; |
| } |
