| // 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_dibbase.h" | |
| #include <algorithm> | |
| #include <array> | |
| #include <utility> | |
| #include "core/fxcrt/check.h" | |
| #include "core/fxcrt/check_op.h" | |
| #include "core/fxcrt/data_vector.h" | |
| #include "core/fxcrt/fx_2d_size.h" | |
| #include "core/fxcrt/fx_coordinates.h" | |
| #include "core/fxcrt/fx_memcpy_wrappers.h" | |
| #include "core/fxcrt/fx_memory.h" | |
| #include "core/fxcrt/fx_safe_types.h" | |
| #include "core/fxcrt/notreached.h" | |
| #include "core/fxcrt/span.h" | |
| #include "core/fxcrt/span_util.h" | |
| #include "core/fxcrt/stl_util.h" | |
| #include "core/fxcrt/zip.h" | |
| #include "core/fxge/calculate_pitch.h" | |
| #include "core/fxge/dib/cfx_bitmapstorer.h" | |
| #include "core/fxge/dib/cfx_dibitmap.h" | |
| #include "core/fxge/dib/cfx_imagestretcher.h" | |
| #include "core/fxge/dib/cfx_imagetransformer.h" | |
| #if defined(PDF_USE_LIBYUV) | |
| #include "core/fxge/fx_libyuv_wrappers.h" | |
| #endif | |
| namespace { | |
| #if defined(PDF_USE_SKIA) | |
| void ConvertBuffer_RgbToArgbPremul( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& src_bitmap) { | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::span<const uint8_t> src_buffer = src_bitmap->GetBuffer(); | |
| if (!src_buffer.empty()) { | |
| pdfium::RGB24ToARGB(src_buffer, src_bitmap->GetPitch(), dest_buf, | |
| dest_pitch, width, height); | |
| return; | |
| } | |
| #endif | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_span = fxcrt::reinterpret_span<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_span = src_bitmap->GetScanlineAs<FX_BGR_STRUCT<uint8_t>>(row); | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::RGB24ToARGBRow(src_span, dest_span); | |
| #else | |
| for (auto [input, output] : fxcrt::Zip(src_span, dest_span)) { | |
| // Avoid interleaved load/stores. | |
| const uint8_t blue = input.blue; | |
| const uint8_t green = input.green; | |
| const uint8_t red = input.red; | |
| output.blue = blue; | |
| output.green = green; | |
| output.red = red; | |
| output.alpha = 255; | |
| } | |
| #endif | |
| } | |
| } | |
| void ConvertBuffer_ArgbPremulToRgb( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& src_bitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_span = fxcrt::reinterpret_span<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_span = src_bitmap->GetScanlineAs<FX_BGRA_STRUCT<uint8_t>>(row); | |
| for (auto [input, output] : fxcrt::Zip(src_span, dest_span)) { | |
| auto unpremultiplied_input = UnPreMultiplyColor(input); | |
| output.blue = unpremultiplied_input.blue; | |
| output.green = unpremultiplied_input.green; | |
| output.red = unpremultiplied_input.red; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_ArgbPremul(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& src_bitmap) { | |
| switch (src_bitmap->GetBPP()) { | |
| case 8: | |
| // TODO(crbug.com/42271020): Determine if this ever happens. | |
| NOTREACHED(); | |
| case 24: | |
| ConvertBuffer_RgbToArgbPremul(dest_buf, dest_pitch, width, height, | |
| src_bitmap); | |
| break; | |
| case 32: | |
| // TODO(crbug.com/42271020): Determine if this ever happens. | |
| NOTREACHED(); | |
| default: | |
| NOTREACHED(); | |
| } | |
| } | |
| #endif // default(PDF_USE_SKIA) | |
| void ConvertBuffer_1bppMaskToGray( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| static constexpr uint8_t kSetGray = 0xff; | |
| static constexpr uint8_t kResetGray = 0x00; | |
| for (int row = 0; row < height; ++row) { | |
| pdfium::span<uint8_t> dest_span = | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)); | |
| pdfium::span<const uint8_t> src_span = pSrcBitmap->GetScanline(row); | |
| std::ranges::fill(dest_span.first(static_cast<size_t>(width)), kResetGray); | |
| uint8_t* dest_scan = dest_span.data(); | |
| const uint8_t* src_scan = src_span.data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < width; ++col) { | |
| if (src_scan[col / 8] & (1 << (7 - col % 8))) { | |
| *dest_scan = kSetGray; | |
| } | |
| ++dest_scan; | |
| } | |
| }); | |
| } | |
| } | |
| void ConvertBuffer_8bppMaskToGray( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| fxcrt::Copy(pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)), | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| } | |
| } | |
| void ConvertBuffer_8bppPltToGray(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& src) { | |
| pdfium::span<const uint32_t> src_palette = src->GetPaletteSpan(); | |
| CHECK_EQ(256u, src_palette.size()); | |
| std::array<uint8_t, 256> gray; | |
| for (auto [input, output] : fxcrt::Zip(src_palette, gray)) { | |
| output = FXRGB2GRAY(FXARGB_R(input), FXARGB_G(input), FXARGB_B(input)); | |
| } | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)); | |
| auto src_scan = src->GetScanline(row).first(static_cast<size_t>(width)); | |
| for (auto [input, output] : fxcrt::Zip(src_scan, dest_scan)) { | |
| output = gray[input]; | |
| } | |
| } | |
| } | |
| template <typename SrcType> | |
| void ConvertBuffer_RgbToGray(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| CHECK_EQ(pSrcBitmap->GetBPP(), 8 * sizeof(SrcType)); | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)); | |
| auto src_scan = pSrcBitmap->GetScanlineAs<SrcType>(row).first( | |
| static_cast<size_t>(width)); | |
| for (auto [src_pix, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| dest_pix = FXRGB2GRAY(src_pix.red, src_pix.green, src_pix.blue); | |
| } | |
| } | |
| } | |
| void ConvertBuffer_IndexCopy(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| if (pSrcBitmap->GetBPP() == 1) { | |
| for (int row = 0; row < height; ++row) { | |
| pdfium::span<uint8_t> dest_span = | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)); | |
| // Set all destination pixels to be white initially. | |
| std::ranges::fill(dest_span.first(static_cast<size_t>(width)), 255); | |
| uint8_t* dest_scan = dest_span.data(); | |
| const uint8_t* src_scan = pSrcBitmap->GetScanline(row).data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < width; ++col) { | |
| // If the source bit is set, then set the destination pixel to be | |
| // black. | |
| if (src_scan[col / 8] & (1 << (7 - col % 8))) { | |
| *dest_scan = 0; | |
| } | |
| ++dest_scan; | |
| } | |
| }); | |
| } | |
| } else { | |
| for (int row = 0; row < height; ++row) { | |
| fxcrt::Copy( | |
| pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)), | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| } | |
| } | |
| } | |
| // Returns a palette of a fixed size. | |
| DataVector<uint32_t> ConvertBuffer_PltToPltRgb8( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| const size_t plt_size = pSrcBitmap->GetRequiredPaletteSize(); | |
| return ToDataVector(pSrcBitmap->GetPaletteSpan().first(plt_size)); | |
| } | |
| void ConvertBuffer_1bppMaskToRgb( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| static constexpr uint8_t kSetGray = 0xff; | |
| static constexpr uint8_t kResetGray = 0x00; | |
| for (int row = 0; row < height; ++row) { | |
| uint8_t* dest_scan = | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)).data(); | |
| const uint8_t* src_scan = pSrcBitmap->GetScanline(row).data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < width; ++col) { | |
| uint8_t value = | |
| (src_scan[col / 8] & (1 << (7 - col % 8))) ? kSetGray : kResetGray; | |
| FXSYS_memset(dest_scan, value, 3); | |
| dest_scan += 3; | |
| } | |
| }); | |
| } | |
| } | |
| void ConvertBuffer_8bppMaskToRgb24( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = fxcrt::reinterpret_span<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_scan = | |
| pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)); | |
| for (auto [src_pix, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| dest_pix = {src_pix, src_pix, src_pix}; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_8bppMaskToRgb32( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = fxcrt::reinterpret_span<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_scan = | |
| pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)); | |
| for (auto [src_pix, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| // This should allow the compiler to assemble a 32-bit word in | |
| // registers followed by a 32-bit store, likely more efficient | |
| // despite the read of the unchanging alpha value. | |
| dest_pix = {src_pix, src_pix, src_pix, dest_pix.alpha}; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_1bppPltToRgb( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| pdfium::span<const uint32_t> src_palette = pSrcBitmap->GetPaletteSpan(); | |
| const uint8_t dst_palette[6] = { | |
| FXARGB_B(src_palette[0]), FXARGB_G(src_palette[0]), | |
| FXARGB_R(src_palette[0]), FXARGB_B(src_palette[1]), | |
| FXARGB_G(src_palette[1]), FXARGB_R(src_palette[1])}; | |
| for (int row = 0; row < height; ++row) { | |
| uint8_t* dest_scan = | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch)).data(); | |
| const uint8_t* src_scan = pSrcBitmap->GetScanline(row).data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < width; ++col) { | |
| size_t offset = (src_scan[col / 8] & (1 << (7 - col % 8))) ? 3 : 0; | |
| FXSYS_memcpy(dest_scan, dst_palette + offset, 3); | |
| dest_scan += 3; | |
| } | |
| }); | |
| } | |
| } | |
| void ConvertBuffer_8bppPltToRgb24( | |
| pdfium::span<FX_BGR_STRUCT<uint8_t>, 256> dst_palette, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = fxcrt::reinterpret_span<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_scan = | |
| pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)); | |
| for (auto [src_index, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| dest_pix = dst_palette[src_index]; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_8bppPltToRgb32( | |
| pdfium::span<FX_BGR_STRUCT<uint8_t>, 256> dst_palette, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = fxcrt::reinterpret_span<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_scan = | |
| pSrcBitmap->GetScanline(row).first(static_cast<size_t>(width)); | |
| for (auto [src_index, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| const auto& pal_pix = dst_palette[src_index]; | |
| // This should allow the compiler to assemble a 32-bit word in | |
| // registers followed by a 32-bit store, likely more efficient | |
| // despite the read of the unchanging alpha value. | |
| dest_pix = {pal_pix.blue, pal_pix.green, pal_pix.red, dest_pix.alpha}; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_1bppToRgb(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| if (pSrcBitmap->HasPalette()) { | |
| ConvertBuffer_1bppPltToRgb(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| } else { | |
| ConvertBuffer_1bppMaskToRgb(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } | |
| } | |
| void ConvertBuffer_8bppToRgb(FXDIB_Format dest_format, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| if (pSrcBitmap->HasPalette()) { | |
| pdfium::span<const uint32_t> src_palette = pSrcBitmap->GetPaletteSpan(); | |
| CHECK_EQ(256u, src_palette.size()); | |
| std::array<FX_BGR_STRUCT<uint8_t>, 256> dst_palette; | |
| for (auto [src_color, dst_color] : fxcrt::Zip(src_palette, dst_palette)) { | |
| dst_color = {FXARGB_B(src_color), FXARGB_G(src_color), | |
| FXARGB_R(src_color)}; | |
| } | |
| if (GetCompsFromFormat(dest_format) == 3) { | |
| ConvertBuffer_8bppPltToRgb24(dst_palette, dest_buf, dest_pitch, width, | |
| height, pSrcBitmap); | |
| } else { | |
| ConvertBuffer_8bppPltToRgb32(dst_palette, dest_buf, dest_pitch, width, | |
| height, pSrcBitmap); | |
| } | |
| } else { | |
| if (GetCompsFromFormat(dest_format) == 3) { | |
| ConvertBuffer_8bppMaskToRgb24(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } else { | |
| ConvertBuffer_8bppMaskToRgb32(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } | |
| } | |
| } | |
| void ConvertBuffer_24bppRgbToRgb24( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| const size_t byte_count = Fx2DSizeOrDie(width, 3); | |
| for (int row = 0; row < height; ++row) { | |
| fxcrt::Copy(pSrcBitmap->GetScanline(row).first(byte_count), | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| } | |
| } | |
| void ConvertBuffer_32bppRgbToRgb24( | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::span<const uint8_t> src_buffer = pSrcBitmap->GetBuffer(); | |
| if (!src_buffer.empty()) { | |
| pdfium::ARGBToRGB24(src_buffer, pSrcBitmap->GetPitch(), dest_buf, | |
| dest_pitch, width, height); | |
| return; | |
| } | |
| #endif | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_span = fxcrt::reinterpret_span<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_span = | |
| pSrcBitmap->GetScanlineAs<FX_BGRA_STRUCT<uint8_t>>(row).first( | |
| static_cast<size_t>(width)); | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::ARGBToRGB24Row(src_span, dest_span); | |
| #else | |
| uint8_t* dest_scan = pdfium::as_writable_bytes(dest_span).data(); | |
| const uint8_t* src_scan = pdfium::as_bytes(src_span).data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < width; ++col) { | |
| FXSYS_memcpy(dest_scan, src_scan, 3); | |
| dest_scan += 3; | |
| src_scan += 4; | |
| } | |
| }); | |
| #endif | |
| } | |
| } | |
| template <typename SrcType> | |
| void ConvertBuffer_RgbToRgb32(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| CHECK_EQ(pSrcBitmap->GetBPP(), 8 * sizeof(SrcType)); | |
| for (int row = 0; row < height; ++row) { | |
| auto dest_scan = fxcrt::reinterpret_span<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf.subspan(Fx2DSizeOrDie(row, dest_pitch))); | |
| auto src_scan = pSrcBitmap->GetScanlineAs<SrcType>(row).first( | |
| static_cast<size_t>(width)); | |
| for (auto [src_pix, dest_pix] : fxcrt::Zip(src_scan, dest_scan)) { | |
| // This should allow the compiler to assemble a 32-bit word in | |
| // registers followed by a 32-bit store, likely more efficient | |
| // despite the read of the unchanging alpha value. | |
| dest_pix = {src_pix.blue, src_pix.green, src_pix.red, dest_pix.alpha}; | |
| } | |
| } | |
| } | |
| void ConvertBuffer_8bppMask(pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| switch (pSrcBitmap->GetBPP()) { | |
| case 1: | |
| CHECK(!pSrcBitmap->HasPalette()); | |
| ConvertBuffer_1bppMaskToGray(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| case 8: | |
| if (pSrcBitmap->HasPalette()) { | |
| ConvertBuffer_8bppPltToGray(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } else { | |
| ConvertBuffer_8bppMaskToGray(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } | |
| break; | |
| case 24: | |
| ConvertBuffer_RgbToGray<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| break; | |
| case 32: | |
| #if defined(PDF_USE_SKIA) | |
| // TODO(crbug.com/42271020): Determine if this ever happens. | |
| CHECK_NE(pSrcBitmap->GetFormat(), FXDIB_Format::kBgraPremul); | |
| #endif | |
| ConvertBuffer_RgbToGray<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| break; | |
| default: | |
| NOTREACHED(); | |
| } | |
| } | |
| void ConvertBuffer_Rgb(FXDIB_Format dest_format, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| switch (pSrcBitmap->GetBPP()) { | |
| case 1: | |
| ConvertBuffer_1bppToRgb(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| break; | |
| case 8: | |
| ConvertBuffer_8bppToRgb(dest_format, dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| case 24: | |
| ConvertBuffer_24bppRgbToRgb24(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| case 32: | |
| #if defined(PDF_USE_SKIA) | |
| if (pSrcBitmap->GetFormat() == FXDIB_Format::kBgraPremul) { | |
| ConvertBuffer_ArgbPremulToRgb(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| } | |
| #endif | |
| ConvertBuffer_32bppRgbToRgb24(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| default: | |
| NOTREACHED(); | |
| } | |
| } | |
| void ConvertBuffer_Argb(FXDIB_Format dest_format, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| switch (pSrcBitmap->GetBPP()) { | |
| case 8: | |
| ConvertBuffer_8bppToRgb(dest_format, dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| break; | |
| case 24: | |
| ConvertBuffer_RgbToRgb32<FX_BGR_STRUCT<uint8_t>>( | |
| dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| break; | |
| case 32: | |
| #if defined(PDF_USE_SKIA) | |
| // TODO(crbug.com/42271020): Determine if this ever happens. | |
| CHECK_NE(pSrcBitmap->GetFormat(), FXDIB_Format::kBgraPremul); | |
| #endif | |
| ConvertBuffer_RgbToRgb32<FX_BGRA_STRUCT<uint8_t>>( | |
| dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| break; | |
| default: | |
| NOTREACHED(); | |
| } | |
| } | |
| } // namespace | |
| CFX_DIBBase::CFX_DIBBase() = default; | |
| CFX_DIBBase::~CFX_DIBBase() = default; | |
| pdfium::span<const uint8_t> CFX_DIBBase::GetBuffer() const { | |
| return pdfium::span<const uint8_t>(); | |
| } | |
| bool CFX_DIBBase::SkipToScanline(int line, PauseIndicatorIface* pPause) const { | |
| return false; | |
| } | |
| size_t CFX_DIBBase::GetEstimatedImageMemoryBurden() const { | |
| return GetRequiredPaletteSize() * sizeof(uint32_t); | |
| } | |
| #if BUILDFLAG(IS_WIN) || defined(PDF_USE_SKIA) | |
| RetainPtr<const CFX_DIBitmap> CFX_DIBBase::RealizeIfNeeded() const { | |
| return Realize(); | |
| } | |
| #endif | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::Realize() const { | |
| return ClipToInternal(nullptr); | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::ClipTo(const FX_RECT& rect) const { | |
| return ClipToInternal(&rect); | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::ClipToInternal( | |
| const FX_RECT* pClip) const { | |
| FX_RECT rect(0, 0, GetWidth(), GetHeight()); | |
| if (pClip) { | |
| rect.Intersect(*pClip); | |
| if (rect.IsEmpty()) { | |
| return nullptr; | |
| } | |
| } | |
| auto pNewBitmap = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) { | |
| return nullptr; | |
| } | |
| pNewBitmap->SetPalette(GetPaletteSpan()); | |
| if (GetBPP() == 1 && rect.left % 8 != 0) { | |
| int left_shift = rect.left % 32; | |
| int right_shift = 32 - left_shift; | |
| int dword_count = pNewBitmap->GetPitch() / 4; | |
| for (int row = rect.top; row < rect.bottom; ++row) { | |
| auto src_span = GetScanlineAs<uint32_t>(row); | |
| auto dst_span = | |
| pNewBitmap->GetWritableScanlineAs<uint32_t>(row - rect.top); | |
| // Bounds check for free with first/subspan. | |
| const uint32_t* src_scan = | |
| src_span | |
| .subspan(static_cast<size_t>(rect.left / 32), | |
| static_cast<size_t>(dword_count + 1)) | |
| .data(); | |
| uint32_t* dst_scan = | |
| dst_span.first(static_cast<size_t>(dword_count)).data(); | |
| UNSAFE_TODO({ | |
| for (int i = 0; i < dword_count; ++i) { | |
| dst_scan[i] = | |
| (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift); | |
| } | |
| }); | |
| } | |
| } else { | |
| std::optional<uint32_t> copy_len = fxge::CalculatePitch8( | |
| pNewBitmap->GetBPP(), /*components=*/1, pNewBitmap->GetWidth()); | |
| if (!copy_len.has_value()) { | |
| return nullptr; | |
| } | |
| copy_len = std::min<uint32_t>(GetPitch(), copy_len.value()); | |
| FX_SAFE_UINT32 offset = rect.left; | |
| offset *= GetBPP(); | |
| offset /= 8; | |
| if (!offset.IsValid()) { | |
| return nullptr; | |
| } | |
| for (int row = rect.top; row < rect.bottom; ++row) { | |
| const uint8_t* src_scan = | |
| GetScanline(row).subspan(offset.ValueOrDie()).data(); | |
| uint8_t* dest_scan = | |
| pNewBitmap->GetWritableScanline(row - rect.top).data(); | |
| UNSAFE_TODO(FXSYS_memcpy(dest_scan, src_scan, copy_len.value())); | |
| } | |
| } | |
| return pNewBitmap; | |
| } | |
| void CFX_DIBBase::BuildPalette() { | |
| if (HasPalette()) { | |
| return; | |
| } | |
| if (GetBPP() == 1) { | |
| palette_ = {0xff000000, 0xffffffff}; | |
| } else if (GetBPP() == 8) { | |
| palette_.resize(256); | |
| for (int i = 0; i < 256; ++i) { | |
| palette_[i] = ArgbEncode(0xff, i, i, i); | |
| } | |
| } | |
| } | |
| size_t CFX_DIBBase::GetRequiredPaletteSize() const { | |
| if (IsMaskFormat()) { | |
| return 0; | |
| } | |
| switch (GetBPP()) { | |
| case 1: | |
| return 2; | |
| case 8: | |
| return 256; | |
| default: | |
| return 0; | |
| } | |
| } | |
| uint32_t CFX_DIBBase::GetPaletteArgb(int index) const { | |
| DCHECK((GetBPP() == 1 || GetBPP() == 8) && !IsMaskFormat()); | |
| if (HasPalette()) { | |
| return GetPaletteSpan()[index]; | |
| } | |
| if (GetBPP() == 1) { | |
| return index ? 0xffffffff : 0xff000000; | |
| } | |
| return ArgbEncode(0xff, index, index, index); | |
| } | |
| void CFX_DIBBase::SetPaletteArgb(int index, uint32_t color) { | |
| DCHECK((GetBPP() == 1 || GetBPP() == 8) && !IsMaskFormat()); | |
| BuildPalette(); | |
| palette_[index] = color; | |
| } | |
| int CFX_DIBBase::FindPalette(uint32_t color) const { | |
| DCHECK((GetBPP() == 1 || GetBPP() == 8) && !IsMaskFormat()); | |
| if (HasPalette()) { | |
| int palsize = (1 << GetBPP()); | |
| pdfium::span<const uint32_t> palette = GetPaletteSpan(); | |
| for (int i = 0; i < palsize; ++i) { | |
| if (palette[i] == color) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| } | |
| if (GetBPP() == 1) { | |
| return (static_cast<uint8_t>(color) == 0xff) ? 1 : 0; | |
| } | |
| return static_cast<uint8_t>(color); | |
| } | |
| bool CFX_DIBBase::GetOverlapRect(int& dest_left, | |
| int& dest_top, | |
| int& width, | |
| int& height, | |
| int src_width, | |
| int src_height, | |
| int& src_left, | |
| int& src_top, | |
| const FX_RECT* clip_rect) const { | |
| if (width == 0 || height == 0) { | |
| return false; | |
| } | |
| DCHECK_GT(width, 0); | |
| DCHECK_GT(height, 0); | |
| if (dest_left > GetWidth() || dest_top > GetHeight()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_src_width = src_left; | |
| safe_src_width += width; | |
| if (!safe_src_width.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_src_height = src_top; | |
| safe_src_height += height; | |
| if (!safe_src_height.IsValid()) { | |
| return false; | |
| } | |
| FX_RECT src_rect(src_left, src_top, safe_src_width.ValueOrDie(), | |
| safe_src_height.ValueOrDie()); | |
| FX_RECT src_bound(0, 0, src_width, src_height); | |
| src_rect.Intersect(src_bound); | |
| FX_SAFE_INT32 safe_x_offset = dest_left; | |
| safe_x_offset -= src_left; | |
| if (!safe_x_offset.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_y_offset = dest_top; | |
| safe_y_offset -= src_top; | |
| if (!safe_y_offset.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_dest_left = safe_x_offset; | |
| safe_dest_left += src_rect.left; | |
| if (!safe_dest_left.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_dest_top = safe_y_offset; | |
| safe_dest_top += src_rect.top; | |
| if (!safe_dest_top.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_dest_right = safe_x_offset; | |
| safe_dest_right += src_rect.right; | |
| if (!safe_dest_right.IsValid()) { | |
| return false; | |
| } | |
| FX_SAFE_INT32 safe_dest_bottom = safe_y_offset; | |
| safe_dest_bottom += src_rect.bottom; | |
| if (!safe_dest_bottom.IsValid()) { | |
| return false; | |
| } | |
| FX_RECT dest_rect(safe_dest_left.ValueOrDie(), safe_dest_top.ValueOrDie(), | |
| safe_dest_right.ValueOrDie(), | |
| safe_dest_bottom.ValueOrDie()); | |
| FX_RECT dest_bound(0, 0, GetWidth(), GetHeight()); | |
| dest_rect.Intersect(dest_bound); | |
| if (clip_rect) { | |
| dest_rect.Intersect(*clip_rect); | |
| } | |
| dest_left = dest_rect.left; | |
| dest_top = dest_rect.top; | |
| FX_SAFE_INT32 safe_new_src_left = dest_left; | |
| safe_new_src_left -= safe_x_offset; | |
| if (!safe_new_src_left.IsValid()) { | |
| return false; | |
| } | |
| src_left = safe_new_src_left.ValueOrDie(); | |
| FX_SAFE_INT32 safe_new_src_top = dest_top; | |
| safe_new_src_top -= safe_y_offset; | |
| if (!safe_new_src_top.IsValid()) { | |
| return false; | |
| } | |
| src_top = safe_new_src_top.ValueOrDie(); | |
| if (dest_rect.IsEmpty()) { | |
| return false; | |
| } | |
| width = dest_rect.Width(); | |
| height = dest_rect.Height(); | |
| return true; | |
| } | |
| void CFX_DIBBase::SetPalette(pdfium::span<const uint32_t> src_palette) { | |
| TakePalette(ToDataVector(src_palette)); | |
| } | |
| void CFX_DIBBase::TakePalette(DataVector<uint32_t> src_palette) { | |
| if (src_palette.empty() || GetBPP() > 8) { | |
| palette_.clear(); | |
| return; | |
| } | |
| palette_ = std::move(src_palette); | |
| uint32_t pal_size = 1 << GetBPP(); | |
| CHECK_LE(pal_size, kPaletteSize); | |
| palette_.resize(pal_size); | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::CloneAlphaMask() const { | |
| // TODO(crbug.com/355676038): Consider adding support for | |
| // `FXDIB_Format::kBgraPremul` | |
| DCHECK_EQ(GetFormat(), FXDIB_Format::kBgra); | |
| auto pMask = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!pMask->Create(GetWidth(), GetHeight(), FXDIB_Format::k8bppMask)) { | |
| return nullptr; | |
| } | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::span<const uint8_t> src_buffer = GetBuffer(); | |
| if (!src_buffer.empty()) { | |
| pdfium::ARGBExtractAlpha(src_buffer, GetPitch(), pMask->GetWritableBuffer(), | |
| pMask->GetPitch(), GetWidth(), GetHeight()); | |
| return pMask; | |
| } | |
| #endif | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::ARGBExtractAlphaRow(GetScanlineAs<FX_BGRA_STRUCT<uint8_t>>(row), | |
| pMask->GetWritableScanlineAs<uint8_t>(row)); | |
| #else | |
| const uint8_t* src_scan = GetScanline(row).subspan<3u>().data(); | |
| uint8_t* dest_scan = pMask->GetWritableScanline(row).data(); | |
| UNSAFE_TODO({ | |
| for (int col = 0; col < GetWidth(); ++col) { | |
| *dest_scan++ = *src_scan; | |
| src_scan += 4; | |
| } | |
| }); | |
| #endif | |
| } | |
| return pMask; | |
| } | |
| #if BUILDFLAG(IS_WIN) || defined(PDF_ENABLE_XFA) | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::FlipImage(bool bXFlip, bool bYFlip) const { | |
| auto pFlipped = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!pFlipped->Create(GetWidth(), GetHeight(), GetFormat())) { | |
| return nullptr; | |
| } | |
| pFlipped->SetPalette(GetPaletteSpan()); | |
| const int bytes_per_pixel = GetBPP() / 8; | |
| if (!bXFlip) { | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = GetScanline(row).data(); | |
| uint8_t* dest_scan = | |
| pFlipped->GetWritableScanline(bYFlip ? GetHeight() - row - 1 : row) | |
| .data(); | |
| FXSYS_memcpy(dest_scan, src_scan, GetPitch()); | |
| }); | |
| } | |
| return pFlipped; | |
| } | |
| if (GetBPP() == 1) { | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = GetScanline(row).data(); | |
| uint8_t* dest_scan = | |
| pFlipped->GetWritableScanline(bYFlip ? GetHeight() - row - 1 : row) | |
| .data(); | |
| FXSYS_memset(dest_scan, 0, GetPitch()); | |
| for (int col = 0; col < GetWidth(); ++col) { | |
| if (src_scan[col / 8] & (1 << (7 - col % 8))) { | |
| int dest_col = GetWidth() - col - 1; | |
| dest_scan[dest_col / 8] |= (1 << (7 - dest_col % 8)); | |
| } | |
| } | |
| }); | |
| } | |
| return pFlipped; | |
| } | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::span<const uint8_t> src_buffer = GetBuffer(); | |
| #endif | |
| if (bytes_per_pixel == 1) { | |
| #if defined(PDF_USE_LIBYUV) | |
| if (!src_buffer.empty()) { | |
| pdfium::MirrorPlane(src_buffer, GetPitch(), pFlipped->GetWritableBuffer(), | |
| pFlipped->GetPitch(), GetWidth(), | |
| bYFlip ? -GetHeight() : GetHeight()); | |
| return pFlipped; | |
| } | |
| #endif | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| auto src_span = GetScanlineAs<uint8_t>(row); | |
| auto dest_span = pFlipped->GetWritableScanlineAs<uint8_t>( | |
| bYFlip ? GetHeight() - row - 1 : row); | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::MirrorPlaneRow(src_span, dest_span); | |
| #else | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = src_span.data(); | |
| uint8_t* dest_scan = dest_span.data(); | |
| dest_scan += (GetWidth() - 1) * bytes_per_pixel; | |
| for (int col = 0; col < GetWidth(); ++col) { | |
| *dest_scan = *src_scan; | |
| --dest_scan; | |
| ++src_scan; | |
| } | |
| }); | |
| #endif | |
| } | |
| return pFlipped; | |
| } | |
| if (bytes_per_pixel == 3) { | |
| #if defined(PDF_USE_LIBYUV) | |
| if (!src_buffer.empty()) { | |
| pdfium::RGB24Mirror(src_buffer, GetPitch(), pFlipped->GetWritableBuffer(), | |
| pFlipped->GetPitch(), GetWidth(), | |
| bYFlip ? -GetHeight() : GetHeight()); | |
| return pFlipped; | |
| } | |
| #endif | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| auto src_span = GetScanlineAs<FX_BGR_STRUCT<uint8_t>>(row); | |
| auto dest_span = pFlipped->GetWritableScanlineAs<FX_BGR_STRUCT<uint8_t>>( | |
| bYFlip ? GetHeight() - row - 1 : row); | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::RGB24MirrorRow(src_span, dest_span); | |
| #else | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = pdfium::as_bytes(src_span).data(); | |
| uint8_t* dest_scan = pdfium::as_writable_bytes(dest_span).data(); | |
| dest_scan += (GetWidth() - 1) * bytes_per_pixel; | |
| for (int col = 0; col < GetWidth(); ++col) { | |
| FXSYS_memcpy(dest_scan, src_scan, 3); | |
| dest_scan -= 3; | |
| src_scan += 3; | |
| } | |
| }); | |
| #endif | |
| } | |
| return pFlipped; | |
| } | |
| CHECK_EQ(bytes_per_pixel, 4); | |
| #if defined(PDF_USE_LIBYUV) | |
| if (!src_buffer.empty()) { | |
| pdfium::ARGBMirror(src_buffer, GetPitch(), pFlipped->GetWritableBuffer(), | |
| pFlipped->GetPitch(), GetWidth(), | |
| bYFlip ? -GetHeight() : GetHeight()); | |
| return pFlipped; | |
| } | |
| #endif | |
| for (int row = 0; row < GetHeight(); ++row) { | |
| auto src_span = GetScanlineAs<FX_BGRA_STRUCT<uint8_t>>(row); | |
| auto dest_span = pFlipped->GetWritableScanlineAs<FX_BGRA_STRUCT<uint8_t>>( | |
| bYFlip ? GetHeight() - row - 1 : row); | |
| #if defined(PDF_USE_LIBYUV) | |
| pdfium::ARGBMirrorRow(src_span, dest_span); | |
| #else | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = pdfium::as_bytes(src_span).data(); | |
| uint8_t* dest_scan = pdfium::as_writable_bytes(dest_span).data(); | |
| dest_scan += (GetWidth() - 1) * bytes_per_pixel; | |
| for (int col = 0; col < GetWidth(); ++col) { | |
| const auto* src_scan32 = reinterpret_cast<const uint32_t*>(src_scan); | |
| uint32_t* dest_scan32 = reinterpret_cast<uint32_t*>(dest_scan); | |
| *dest_scan32 = *src_scan32; | |
| dest_scan -= 4; | |
| src_scan += 4; | |
| } | |
| }); | |
| #endif | |
| } | |
| return pFlipped; | |
| } | |
| #endif // BUILDFLAG(IS_WIN) || defined(PDF_ENABLE_XFA) | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::ConvertTo(FXDIB_Format dest_format) const { | |
| CHECK(dest_format == FXDIB_Format::kBgr || | |
| dest_format == FXDIB_Format::k8bppRgb); | |
| CHECK_NE(dest_format, GetFormat()); | |
| auto pClone = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| if (!pClone->Create(GetWidth(), GetHeight(), dest_format)) { | |
| return nullptr; | |
| } | |
| RetainPtr<const CFX_DIBBase> holder(this); | |
| DataVector<uint32_t> pal_8bpp = | |
| ConvertBuffer(dest_format, pClone->GetWritableBuffer(), | |
| pClone->GetPitch(), GetWidth(), GetHeight(), holder); | |
| if (!pal_8bpp.empty()) { | |
| pClone->TakePalette(std::move(pal_8bpp)); | |
| } | |
| return pClone; | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::SwapXY(bool bXFlip, bool bYFlip) const { | |
| FX_RECT dest_clip(0, 0, GetHeight(), GetWidth()); | |
| if (dest_clip.IsEmpty()) { | |
| return nullptr; | |
| } | |
| auto pTransBitmap = pdfium::MakeRetain<CFX_DIBitmap>(); | |
| const int result_height = dest_clip.Height(); | |
| const int result_width = dest_clip.Width(); | |
| if (!pTransBitmap->Create(result_width, result_height, GetFormat())) { | |
| return nullptr; | |
| } | |
| pTransBitmap->SetPalette(GetPaletteSpan()); | |
| const int dest_pitch = pTransBitmap->GetPitch(); | |
| pdfium::span<uint8_t> dest_span = pTransBitmap->GetWritableBuffer().first( | |
| Fx2DSizeOrDie(dest_pitch, result_height)); | |
| const size_t dest_last_row_offset = | |
| Fx2DSizeOrDie(dest_pitch, result_height - 1); | |
| const int row_start = bXFlip ? GetHeight() - dest_clip.right : dest_clip.left; | |
| const int row_end = bXFlip ? GetHeight() - dest_clip.left : dest_clip.right; | |
| const int col_start = bYFlip ? GetWidth() - dest_clip.bottom : dest_clip.top; | |
| const int col_end = bYFlip ? GetWidth() - dest_clip.top : dest_clip.bottom; | |
| if (GetBPP() == 1) { | |
| std::ranges::fill(dest_span, 0xff); | |
| if (bYFlip) { | |
| dest_span = dest_span.subspan(dest_last_row_offset); | |
| } | |
| const int dest_step = bYFlip ? -dest_pitch : dest_pitch; | |
| for (int row = row_start; row < row_end; ++row) { | |
| UNSAFE_TODO({ | |
| const uint8_t* src_scan = GetScanline(row).data(); | |
| int dest_col = | |
| (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - | |
| dest_clip.left; | |
| uint8_t* dest_scan = dest_span.data(); | |
| for (int col = col_start; col < col_end; ++col) { | |
| if (!(src_scan[col / 8] & (1 << (7 - col % 8)))) { | |
| dest_scan[dest_col / 8] &= ~(1 << (7 - dest_col % 8)); | |
| } | |
| dest_scan += dest_step; | |
| } | |
| }); | |
| } | |
| return pTransBitmap; | |
| } | |
| const int bytes_per_pixel = GetBPP() / 8; | |
| #if defined(PDF_USE_LIBYUV) | |
| if (bytes_per_pixel == 1 || bytes_per_pixel == 4) { | |
| pdfium::span<const uint8_t> src_buffer = GetBuffer(); | |
| if (!src_buffer.empty()) { | |
| const int height = bXFlip == bYFlip ? -GetHeight() : GetHeight(); | |
| const pdfium::RotationMode mode = | |
| bYFlip ? pdfium::kRotate270 : pdfium::kRotate90; | |
| if (bytes_per_pixel == 1) { | |
| pdfium::RotatePlane(src_buffer, GetPitch(), dest_span, dest_pitch, | |
| GetWidth(), height, mode); | |
| } else { | |
| pdfium::ARGBRotate(src_buffer, GetPitch(), dest_span, dest_pitch, | |
| GetWidth(), height, mode); | |
| } | |
| return pTransBitmap; | |
| } | |
| } | |
| #endif | |
| int dest_step = bYFlip ? -dest_pitch : dest_pitch; | |
| if (bytes_per_pixel == 3) { | |
| dest_step -= 2; | |
| } | |
| if (bYFlip) { | |
| dest_span = dest_span.subspan(dest_last_row_offset); | |
| } | |
| if (bytes_per_pixel == 1) { | |
| for (int row = row_start; row < row_end; ++row) { | |
| UNSAFE_TODO({ | |
| int dest_col = | |
| (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - | |
| dest_clip.left; | |
| size_t dest_offset = Fx2DSizeOrDie(dest_col, bytes_per_pixel); | |
| uint8_t* dest_scan = dest_span.subspan(dest_offset).data(); | |
| const uint8_t* src_scan = | |
| GetScanline(row) | |
| .subspan(static_cast<size_t>(col_start * bytes_per_pixel)) | |
| .data(); | |
| for (int col = col_start; col < col_end; ++col) { | |
| *dest_scan = *src_scan++; | |
| dest_scan += dest_step; | |
| } | |
| }); | |
| } | |
| return pTransBitmap; | |
| } | |
| if (bytes_per_pixel == 3) { | |
| for (int row = row_start; row < row_end; ++row) { | |
| UNSAFE_TODO({ | |
| int dest_col = | |
| (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - | |
| dest_clip.left; | |
| size_t dest_offset = Fx2DSizeOrDie(dest_col, bytes_per_pixel); | |
| uint8_t* dest_scan = dest_span.subspan(dest_offset).data(); | |
| const uint8_t* src_scan = | |
| GetScanline(row) | |
| .subspan(static_cast<size_t>(col_start * bytes_per_pixel)) | |
| .data(); | |
| for (int col = col_start; col < col_end; ++col) { | |
| FXSYS_memcpy(dest_scan, src_scan, 3); | |
| dest_scan += 2 + dest_step; | |
| src_scan += 3; | |
| } | |
| }); | |
| } | |
| return pTransBitmap; | |
| } | |
| CHECK_EQ(bytes_per_pixel, 4); | |
| for (int row = row_start; row < row_end; ++row) { | |
| UNSAFE_TODO({ | |
| int dest_col = (bXFlip ? dest_clip.right - (row - row_start) - 1 : row) - | |
| dest_clip.left; | |
| size_t dest_offset = Fx2DSizeOrDie(dest_col, bytes_per_pixel); | |
| uint8_t* dest_scan = dest_span.subspan(dest_offset).data(); | |
| const uint32_t* src_scan = GetScanlineAs<uint32_t>(row) | |
| .subspan(static_cast<size_t>(col_start)) | |
| .data(); | |
| for (int col = col_start; col < col_end; ++col) { | |
| uint32_t* dest_scan32 = reinterpret_cast<uint32_t*>(dest_scan); | |
| *dest_scan32 = *src_scan++; | |
| dest_scan += dest_step; | |
| } | |
| }); | |
| } | |
| return pTransBitmap; | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::TransformTo(const CFX_Matrix& mtDest, | |
| int* result_left, | |
| int* result_top) const { | |
| RetainPtr<const CFX_DIBBase> holder(this); | |
| CFX_ImageTransformer transformer(holder, mtDest, FXDIB_ResampleOptions(), | |
| nullptr); | |
| transformer.Continue(nullptr); | |
| *result_left = transformer.result().left; | |
| *result_top = transformer.result().top; | |
| return transformer.DetachBitmap(); | |
| } | |
| RetainPtr<CFX_DIBitmap> CFX_DIBBase::StretchTo( | |
| int dest_width, | |
| int dest_height, | |
| const FXDIB_ResampleOptions& options, | |
| const FX_RECT* pClip) const { | |
| RetainPtr<const CFX_DIBBase> holder(this); | |
| FX_RECT clip_rect(0, 0, abs(dest_width), abs(dest_height)); | |
| if (pClip) { | |
| clip_rect.Intersect(*pClip); | |
| } | |
| if (clip_rect.IsEmpty()) { | |
| return nullptr; | |
| } | |
| if (dest_width == GetWidth() && dest_height == GetHeight()) { | |
| return ClipTo(clip_rect); | |
| } | |
| CFX_BitmapStorer storer; | |
| CFX_ImageStretcher stretcher(&storer, holder, dest_width, dest_height, | |
| clip_rect, options); | |
| if (stretcher.Start()) { | |
| stretcher.Continue(nullptr); | |
| } | |
| return storer.Detach(); | |
| } | |
| // static | |
| DataVector<uint32_t> CFX_DIBBase::ConvertBuffer( | |
| FXDIB_Format dest_format, | |
| pdfium::span<uint8_t> dest_buf, | |
| int dest_pitch, | |
| int width, | |
| int height, | |
| const RetainPtr<const CFX_DIBBase>& pSrcBitmap) { | |
| switch (dest_format) { | |
| case FXDIB_Format::kInvalid: | |
| case FXDIB_Format::k1bppRgb: | |
| case FXDIB_Format::k1bppMask: { | |
| NOTREACHED(); | |
| } | |
| case FXDIB_Format::k8bppMask: { | |
| ConvertBuffer_8bppMask(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| return {}; | |
| } | |
| case FXDIB_Format::k8bppRgb: { | |
| const int src_bpp = pSrcBitmap->GetBPP(); | |
| CHECK(src_bpp == 1 || src_bpp == 8); | |
| if (pSrcBitmap->HasPalette()) { | |
| return ConvertBuffer_PltToPltRgb8(dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| } | |
| ConvertBuffer_8bppMask(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| return {}; | |
| } | |
| case FXDIB_Format::kBgr: { | |
| ConvertBuffer_Rgb(dest_format, dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| return {}; | |
| } | |
| case FXDIB_Format::kBgra: | |
| case FXDIB_Format::kBgrx: { | |
| ConvertBuffer_Argb(dest_format, dest_buf, dest_pitch, width, height, | |
| pSrcBitmap); | |
| return {}; | |
| } | |
| #if defined(PDF_USE_SKIA) | |
| case FXDIB_Format::kBgraPremul: { | |
| ConvertBuffer_ArgbPremul(dest_buf, dest_pitch, width, height, pSrcBitmap); | |
| return {}; | |
| } | |
| #endif | |
| } | |
| } |