remove some calls to dib

core/fxge/skia/fx_skia_device.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/fxge/include/fx_ge.h"
 
 #if defined(_SKIA_SUPPORT_)
 #include "core/fxcodec/include/fx_codec.h"
 
 #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h"
@@ skipping 63 matching lines @@
 #else  // DRAW_SKIA_CLIP
 
 void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
 void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {}
 
 #endif  // DRAW_SKIA_CLIP
 
 #undef SHOW_SKIA_PATH
 #undef DRAW_SKIA_CLIP
 
+static void DebugVerifyBitmapIsPreMultiplied(void* buffer,
+                                             int width,
+                                             int height) {
+#ifdef SK_DEBUG
+  // verify that input is really premultiplied
+  for (int y = 0; y < height; ++y) {
+    const uint32_t* srcRow = static_cast<const uint32_t*>(buffer) + y * width;
+    for (int x = 0; x < width; ++x) {
+      uint8_t a = SkGetPackedA32(srcRow[x]);
+      uint8_t r = SkGetPackedR32(srcRow[x]);
+      uint8_t g = SkGetPackedG32(srcRow[x]);
+      uint8_t b = SkGetPackedB32(srcRow[x]);
+      SkA32Assert(a);
+      SkASSERT(r <= a);
+      SkASSERT(g <= a);
+      SkASSERT(b <= a);
+    }
+  }
+#endif
+}
+
+static void DebugValidate(const CFX_DIBitmap* bitmap,
+                          const CFX_DIBitmap* device) {
+  if (bitmap) {
+    SkASSERT(bitmap->GetBPP() == 8 || bitmap->GetBPP() == 32);
+    if (bitmap->GetBPP() == 32) {
+      DebugVerifyBitmapIsPreMultiplied(bitmap->GetBuffer(), bitmap->GetWidth(),
+                                       bitmap->GetHeight());
+    }
+  }
+  if (device) {
+    SkASSERT(device->GetBPP() == 8 || device->GetBPP() == 32);
+    if (device->GetBPP() == 32) {
+      DebugVerifyBitmapIsPreMultiplied(device->GetBuffer(), device->GetWidth(),
+                                       device->GetHeight());
+    }
+  }
+}
+
 SkPath BuildPath(const CFX_PathData* pPathData) {
   SkPath skPath;
   const CFX_PathData* pFPath = pPathData;
   int nPoints = pFPath->GetPointCount();
   FX_PATHPOINT* pPoints = pFPath->GetPoints();
   for (int i = 0; i < nPoints; i++) {
     FX_FLOAT x = pPoints[i].m_PointX;
     FX_FLOAT y = pPoints[i].m_PointY;
     int point_type = pPoints[i].m_Flag & FXPT_TYPE;
     if (point_type == FXPT_MOVETO) {
@@ skipping 408 matching lines @@
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
                                            FX_BOOL bRgbByteOrder,
                                            CFX_DIBitmap* pOriDevice,
                                            FX_BOOL bGroupKnockout)
     : m_pBitmap(pBitmap),
       m_pOriDevice(pOriDevice),
       m_pRecorder(nullptr),
       m_bRgbByteOrder(bRgbByteOrder),
       m_bGroupKnockout(bGroupKnockout) {
   SkBitmap skBitmap;
-  SkImageInfo imageInfo =
-      SkImageInfo::Make(pBitmap->GetWidth(), pBitmap->GetHeight(),
-                        kN32_SkColorType, kOpaque_SkAlphaType);
+  SkASSERT(pBitmap->GetBPP() == 8 || pBitmap->GetBPP() == 32);
+  SkImageInfo imageInfo = SkImageInfo::Make(
+      pBitmap->GetWidth(), pBitmap->GetHeight(),
+      pBitmap->GetBPP() == 8 ? kAlpha_8_SkColorType : kN32_SkColorType,
+      kOpaque_SkAlphaType);
   skBitmap.installPixels(imageInfo, pBitmap->GetBuffer(), pBitmap->GetPitch(),
                          nullptr, /* to do : set color table */
                          nullptr, nullptr);
   m_pCanvas = new SkCanvas(skBitmap);
   if (m_bGroupKnockout)
     SkDebugf("");  // FIXME(caryclark) suppress 'm_bGroupKnockout is unused'
 }
 
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(int size_x, int size_y)
     : m_pBitmap(nullptr),
@@ skipping 21 matching lines @@
 
 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                              const FXTEXT_CHARPOS* pCharPos,
                                              CFX_Font* pFont,
                                              CFX_FontCache* pCache,
                                              const CFX_Matrix* pObject2Device,
                                              FX_FLOAT font_size,
                                              uint32_t color,
                                              int alpha_flag,
                                              void* pIccTransform) {
-  CFX_TypeFace* typeface = pCache->GetDeviceCache(pFont);
+  sk_sp<SkTypeface> typeface(SkSafeRef(pCache->GetDeviceCache(pFont)));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setTextSize(font_size);
   paint.setSubpixelText(true);
   m_pCanvas->save();
   SkMatrix skMatrix = ToFlippedSkMatrix(*pObject2Device);
   m_pCanvas->concat(skMatrix);
@@ skipping 358 matching lines @@
 FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                         uint32_t argb,
                                         const FX_RECT* pSrcRect,
                                         int left,
                                         int top,
                                         int blend_type,
                                         int alpha_flag,
                                         void* pIccTransform) {
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
     return TRUE;
-  if (pBitmap->IsAlphaMask()) {
-    return m_pBitmap->CompositeMask(
-        left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
-        pSrcRect->left, pSrcRect->top, blend_type, nullptr, m_bRgbByteOrder,
-        alpha_flag, pIccTransform);
-  }
-  return m_pBitmap->CompositeBitmap(
-      left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
-      pSrcRect->top, blend_type, nullptr, m_bRgbByteOrder, pIccTransform);
+
+  CFX_Matrix m(pBitmap->GetWidth(), 0, 0, -pBitmap->GetHeight(), left,
+               top + pBitmap->GetHeight());
+  void* dummy;
+  return this->StartDIBits(pBitmap, 0xFF, argb, &m, 0, dummy, alpha_flag,
+                           pIccTransform, blend_type);
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                             uint32_t argb,
                                             int dest_left,
                                             int dest_top,
                                             int dest_width,
                                             int dest_height,
                                             const FX_RECT* pClipRect,
                                             uint32_t flags,
                                             int alpha_flag,
                                             void* pIccTransform,
                                             int blend_type) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
-  if (dest_width == pSource->GetWidth() &&
-      dest_height == pSource->GetHeight()) {
-    FX_RECT rect(0, 0, dest_width, dest_height);
-    return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type,
-                     alpha_flag, pIccTransform);
-  }
-  FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
-                    dest_top + dest_height);
-  dest_rect.Normalize();
-  FX_RECT dest_clip = dest_rect;
-  dest_clip.Intersect(*pClipRect);
-  CFX_BitmapComposer composer;
-  composer.Compose(m_pBitmap, nullptr, 255, argb, dest_clip, FALSE, FALSE,
-                   FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform,
-                   blend_type);
-  dest_clip.Offset(-dest_rect.left, -dest_rect.top);
-  CFX_ImageStretcher stretcher(&composer, pSource, dest_width, dest_height,
-                               dest_clip, flags);
-  if (stretcher.Start())
-    stretcher.Continue(nullptr);
-  return TRUE;
+  CFX_Matrix m(dest_width, 0, 0, -dest_height, dest_left,
+               dest_top + dest_height);
+
+  m_pCanvas->save();
+  SkRect skClipRect = SkRect::MakeLTRB(pClipRect->left, pClipRect->bottom,
+                                       pClipRect->right, pClipRect->top);
+  m_pCanvas->clipRect(skClipRect);
+  void* dummy;
+  FX_BOOL result = this->StartDIBits(pSource, 0xFF, argb, &m, 0, dummy,
+                                     alpha_flag, pIccTransform, blend_type);
+  m_pCanvas->restore();
+
+  return result;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                           int bitmap_alpha,
                                           uint32_t argb,
                                           const CFX_Matrix* pMatrix,
                                           uint32_t render_flags,
                                           void*& handle,
                                           int alpha_flag,
                                           void* pIccTransform,
                                           int blend_type) {
+  DebugValidate(m_pBitmap, m_pOriDevice);
   SkColorType colorType = pSource->IsAlphaMask()
                               ? SkColorType::kAlpha_8_SkColorType
                               : SkColorType::kGray_8_SkColorType;
+  SkAlphaType alphaType =
+      pSource->IsAlphaMask() ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
   SkColorTable* ct = nullptr;
   void* buffer = pSource->GetBuffer();
   std::unique_ptr<uint8_t, FxFreeDeleter> dst8Storage;
   std::unique_ptr<uint32_t, FxFreeDeleter> dst32Storage;
   int width = pSource->GetWidth();
   int height = pSource->GetHeight();
   int rowBytes = pSource->GetPitch();
   switch (pSource->GetBPP()) {
     case 1: {
       dst8Storage.reset(FX_Alloc2D(uint8_t, width, height));
@@ skipping 14 matching lines @@
         colorType = SkColorType::kIndex_8_SkColorType;
       }
       break;
     case 24: {
       dst32Storage.reset(FX_Alloc2D(uint32_t, width, height));
       uint32_t* dst32Pixels = dst32Storage.get();
       for (int y = 0; y < height; ++y) {
         const uint8_t* srcRow =
             static_cast<const uint8_t*>(buffer) + y * rowBytes;
         uint32_t* dstRow = dst32Pixels + y * width;
-        for (int x = 0; x < width; ++x)
+        for (int x = 0; x < width; ++x) {
           dstRow[x] = SkPackARGB32(0xFF, srcRow[x * 3 + 2], srcRow[x * 3 + 1],
                                    srcRow[x * 3 + 0]);
+        }
       }
       buffer = dst32Storage.get();
       rowBytes = width * sizeof(uint32_t);
       colorType = SkColorType::kN32_SkColorType;
+      alphaType = kOpaque_SkAlphaType;
     } break;
     case 32:
       colorType = SkColorType::kN32_SkColorType;
+      alphaType = kPremul_SkAlphaType;
+      DebugVerifyBitmapIsPreMultiplied(buffer, width, height);
       break;
     default:
+      SkASSERT(0);  // TODO(caryclark) ensure that all cases are covered
       colorType = SkColorType::kUnknown_SkColorType;
   }
-  SkImageInfo imageInfo = SkImageInfo::Make(
-      width, height, colorType,
-      pSource->IsAlphaMask() ? kPremul_SkAlphaType : kOpaque_SkAlphaType);
+  SkImageInfo imageInfo =
+      SkImageInfo::Make(width, height, colorType, alphaType);
   SkBitmap skBitmap;
   skBitmap.installPixels(imageInfo, buffer, rowBytes, ct, nullptr, nullptr);
   m_pCanvas->save();
   SkMatrix skMatrix;
   const CFX_Matrix& m = *pMatrix;
   skMatrix.setAll(m.a / width, -m.c / height, m.c + m.e, m.b / width,
                   -m.d / height, m.d + m.f, 0, 0, 1);
   m_pCanvas->concat(skMatrix);
   SkPaint paint;
   paint.setAntiAlias(true);
   if (pSource->IsAlphaMask()) {
     paint.setColorFilter(
         SkColorFilter::MakeModeFilter(argb, SkXfermode::kSrc_Mode));
   }
   // paint.setFilterQuality(kHigh_SkFilterQuality);
   paint.setXfermodeMode(GetSkiaBlendMode(blend_type));
   paint.setAlpha(bitmap_alpha);
   m_pCanvas->drawBitmap(skBitmap, 0, 0, &paint);
   m_pCanvas->restore();
   if (ct)
     ct->unref();
+  DebugValidate(m_pBitmap, m_pOriDevice);
   return TRUE;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
-  if (!m_pBitmap->GetBuffer())
-    return TRUE;
-  return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
-}
-
-void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle) {
-  if (!m_pBitmap->GetBuffer())
+void CFX_SkiaDeviceDriver::PreMultiply() {
+  void* buffer = m_pBitmap->GetBuffer();
+  if (!buffer)
     return;
-  delete (CFX_ImageRenderer*)pHandle;
+  if (m_pBitmap->GetBPP() != 32) {
+    return;
+  }
+  int height = m_pBitmap->GetHeight();
+  int width = m_pBitmap->GetWidth();
+  int rowBytes = m_pBitmap->GetPitch();
+  SkImageInfo unpremultipliedInfo =
+      SkImageInfo::Make(width, height, kN32_SkColorType, kUnpremul_SkAlphaType);
+  SkPixmap unpremultiplied(unpremultipliedInfo, buffer, rowBytes);
+  SkImageInfo premultipliedInfo =
+      SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
+  SkPixmap premultiplied(premultipliedInfo, buffer, rowBytes);
+  unpremultiplied.readPixels(premultiplied);
+  DebugVerifyBitmapIsPreMultiplied(buffer, width, height);
 }
 
 CFX_FxgeDevice::CFX_FxgeDevice() {
   m_bOwnedBitmap = FALSE;
 }
 
 SkPictureRecorder* CFX_FxgeDevice::CreateRecorder(int size_x, int size_y) {
   CFX_SkiaDeviceDriver* skDriver = new CFX_SkiaDeviceDriver(size_x, size_y);
   SetDeviceDriver(skDriver);
   return skDriver->GetRecorder();
@@ skipping 33 matching lines @@
       new CFX_SkiaDeviceDriver(pBitmap, FALSE, pOriDevice, FALSE);
   SetDeviceDriver(pDriver);
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap && GetBitmap())
     delete GetBitmap();
 }
 
+void CFX_FxgeDevice::PreMultiply() {
+  (static_cast<CFX_SkiaDeviceDriver*>(this->GetDeviceDriver()))->PreMultiply();
+}
+
 #endif