path: root/core/src/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/include/fxge/fx_ge.h"

#if defined(_SKIA_SUPPORT_)
#include "core/include/fxcodec/fx_codec.h"

#include "SkDashPathEffect.h"
#include "SkRasterClip.h"
#include "SkScan.h"
#include "SkStroke.h"
#include "SkTLazy.h"

#include "core/src/fxge/agg/include/fx_agg_driver.h"
#include "core/src/fxge/skia/fx_skia_blitter_new.h"
#include "core/src/fxge/skia/fx_skia_device.h"

extern "C" {
extern void FX_OUTPUT_LOG_FUNC(const char*, ...);
extern int FX_GET_TICK_FUNC();
};

#ifdef _FOXIT_DEBUG_
#define FOXIT_DEBUG1(msg) FX_OUTPUT_LOG_FUNC(msg)
#define FOXIT_DEBUG2(msg, para) FX_OUTPUT_LOG_FUNC(msg, para)
#define FOXIT_DEBUG3(msg, para1, para2) FX_OUTPUT_LOG_FUNC(msg, para1, para2)
#define FOXIT_DEBUG4(msg, para1, para2, para3) \
  FX_OUTPUT_LOG_FUNC(msg, para1, para2, para3)
#define FOXIT_DEBUG5(msg, para1, para2, para3, param4) \
  FX_OUTPUT_LOG_FUNC(msg, para1, para2, para3, param4)
#else
#define FOXIT_DEBUG1(msg)
#define FOXIT_DEBUG2(msg, para)
#define FOXIT_DEBUG3(msg, para1, para2)
#define FOXIT_DEBUG4(msg, para1, para2, para3)
#define FOXIT_DEBUG5(msg, para1, para2, para3, param4)
#endif

/// Run-length-encoded supersampling antialiased blitter.
class SuperBlitter_skia {
 public:
  static void DrawPath(const SkPath& srcPath,
                       SkBlitter* blitter,
                       const SkRasterClip& rect,
                       const SkPaint& origPaint);
};
FX_BOOL FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
  if (SkPaint::kStroke_Style != paint.getStyle())
    return FALSE;
  FXSYS_assert(coverage);
  SkScalar strokeWidth = paint.getStrokeWidth();
  if (0 == strokeWidth) {
    *coverage = SK_Scalar1;
    return TRUE;
  }
  // if we get here, we need to try to fake a thick-stroke with a modulated
  // hairline
  if (!paint.isAntiAlias())
    return FALSE;
  if (strokeWidth <= SK_Scalar1) {
    *coverage = strokeWidth;
    return TRUE;
  }
  return FALSE;
}

void SuperBlitter_skia::DrawPath(const SkPath& srcPath,
                                 SkBlitter* blitter,
                                 const SkRasterClip& rect,
                                 const SkPaint& origPaint) {
  SkPath* pathPtr = (SkPath*)&srcPath;
  bool doFill = true;
  SkPath tmpPath;
  SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
  {
    SkScalar coverage;
    if (FxSkDrawTreatAsHairline(origPaint, &coverage)) {
      if (SK_Scalar1 == coverage) {
        paint.writable()->setStrokeWidth(0);
      } else if (1) {  // xfermodeSupportsCoverageAsAlpha(xfer), we not use
                       // blend mode here, xfer aways NULL.
        U8CPU newAlpha;
        // this is the old technique, which we preserve for now so
        // we don't change previous results (testing)
        // the new way seems fine, its just (a tiny bit) different
        int scale = (int)SkScalarMul(coverage, 256);
        newAlpha = origPaint.getAlpha() * scale >> 8;
        SkPaint* writablePaint = paint.writable();
        writablePaint->setStrokeWidth(0);
        writablePaint->setAlpha(newAlpha);
      }
    }
  }
  if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
    SkIRect devBounds = rect.getBounds();
    // outset to have slop for antialasing and hairlines
    devBounds.outset(1, 1);
    SkRect cullRect = SkRect::Make(devBounds);
    doFill = paint->getFillPath(*pathPtr, &tmpPath, &cullRect);
    pathPtr = &tmpPath;
  }
  // avoid possibly allocating a new path in transform if we can
  SkPath* devPathPtr = pathPtr;
  void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
  if (doFill) {
    if (paint->isAntiAlias()) {
      proc = SkScan::AntiFillPath;
    } else {
      proc = SkScan::FillPath;
    }
  } else {  // hairline
    if (paint->isAntiAlias()) {
      proc = SkScan::AntiHairPath;
    } else {
      proc = SkScan::HairPath;
    }
  }
  proc(*devPathPtr, rect, blitter);
}

class CSkia_PathData {
 public:
  CSkia_PathData() {}
  ~CSkia_PathData() {}
  SkPath m_PathData;

  void BuildPath(const CFX_PathData* pPathData,
                 const CFX_Matrix* pObject2Device);
};

void CSkia_PathData::BuildPath(const CFX_PathData* pPathData,
                               const CFX_Matrix* pObject2Device) {
  const CFX_PathData* pFPath = pPathData;
  int nPoints = pFPath->GetPointCount();
  FX_PATHPOINT* pPoints = pFPath->GetPoints();
  for (int i = 0; i < nPoints; i++) {
    FX_FIXFLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY;
    if (pObject2Device)
      pObject2Device->Transform(x, y);
    int point_type = pPoints[i].m_Flag & FXPT_TYPE;
    if (point_type == FXPT_MOVETO) {
      m_PathData.moveTo(x, y);
    } else if (point_type == FXPT_LINETO) {
      if (pPoints[i - 1].m_Flag == FXPT_MOVETO &&
          (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) &&
          FXSYS_abs(pPoints[i].m_PointX - pPoints[i - 1].m_PointX) < 0.4f &&
          FXSYS_abs(pPoints[i].m_PointY - pPoints[i - 1].m_PointY) < 0.4f)
        // PDF line includes the destination point, unlike Windows line.
        // We received some PDF which actually draws zero length lines. TESTDOC:
        // summer cha show.pdf
        // Therefore, we have to extend the line by 0.4 pixel here.
        // But only for standalone segment. TESTDOC: bug #1434 - maze.pdf;
        // TESTDOC: bug#1508 di704P_QIG_111.pdf
        x += 0.4;
      // TODO: we should actually tell skia vertex generator to process zero
      // length stroked line
      // (only butts are drawn)
      m_PathData.lineTo(x, y);
    } else if (point_type == FXPT_BEZIERTO) {
      FX_FIXFLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY;
      FX_FIXFLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY;
      if (pObject2Device) {
        pObject2Device->Transform(x2, y2);
        pObject2Device->Transform(x3, y3);
      }
      m_PathData.cubicTo(x, y, x2, y2, x3, y3);
      i += 2;
    }
    if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE)
      m_PathData.close();
  }
}

// convert a stroking path to scanlines
static void SkRasterizeStroke(SkPaint& spaint,
                              SkPath* dstPathData,
                              SkPath& path_data,
                              const CFX_Matrix* pObject2Device,
                              const CFX_GraphStateData* pGraphState,
                              FX_FIXFLOAT scale = FIX8_ONE,
                              FX_BOOL bStrokeAdjust = FALSE,
                              FX_BOOL bTextMode = FALSE) {
  SkPaint::Cap cap;
  switch (pGraphState->m_LineCap) {
    case CFX_GraphStateData::LineCapRound:
      cap = SkPaint::kRound_Cap;
      break;
    case CFX_GraphStateData::LineCapSquare:
      cap = SkPaint::kSquare_Cap;
      break;
    default:
      cap = SkPaint::kButt_Cap;
      break;
  }
  SkPaint::Join join;
  switch (pGraphState->m_LineJoin) {
    case CFX_GraphStateData::LineJoinRound:
      join = SkPaint::kRound_Join;
      break;
    case CFX_GraphStateData::LineJoinBevel:
      join = SkPaint::kBevel_Join;
      break;
    default:
      join = SkPaint::kMiter_Join;
      break;
  }
  FX_FIXFLOAT width = pGraphState->m_LineWidth * scale;
  FX_FIXFLOAT unit = fix32_to_8(fixdiv_8_8_to_32(
      FIX8_ONE, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2));
  if (width <= unit)
    width = unit;

  if (pGraphState->m_DashArray) {
    int count = (pGraphState->m_DashCount + 1) / 2;
    SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
    // Set dash pattern
    for (int i = 0; i < count; i++) {
      FX_FIXFLOAT on = pGraphState->m_DashArray[i * 2];
      if (on <= 0.000001f)
        on = FIX8_ONE / 10;
      FX_FIXFLOAT off = i * 2 + 1 == pGraphState->m_DashCount
                            ? on
                            : pGraphState->m_DashArray[i * 2 + 1];
      if (off < 0)
        off = 0;
      intervals[i * 2] = on * scale;
      intervals[i * 2 + 1] = off * scale;
    }
    SkDashPathEffect* pEffect = new SkDashPathEffect(
        intervals, count * 2, pGraphState->m_DashPhase * scale);
    spaint.setPathEffect(pEffect)->unref();
    spaint.setStrokeWidth(width);
    spaint.setStrokeMiter(pGraphState->m_MiterLimit);
    spaint.setStrokeCap(cap);
    spaint.setStrokeJoin(join);
    spaint.getFillPath(path_data, dstPathData);
    SkMatrix smatrix;
    smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e,
                   pObject2Device->b, pObject2Device->d, pObject2Device->f, 0,
                   0, 1);
    dstPathData->transform(smatrix);
    FX_Free(intervals);
  } else {
    SkStroke stroker;
    stroker.setCap(cap);
    stroker.setJoin(join);
    stroker.setMiterLimit(pGraphState->m_MiterLimit);
    stroker.setWidth(width);
    stroker.setDoFill(FALSE);
    stroker.strokePath(path_data, dstPathData);
    SkMatrix smatrix;
    smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e,
                   pObject2Device->b, pObject2Device->d, pObject2Device->f, 0,
                   0, 1);
    dstPathData->transform(smatrix);
  }
}

CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
                                           int dither_bits,
                                           FX_BOOL bRgbByteOrder,
                                           CFX_DIBitmap* pOriDevice,
                                           FX_BOOL bGroupKnockout) {
  m_pAggDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder,
                                         pOriDevice, bGroupKnockout);
}
CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() {
  delete m_pAggDriver;
}
FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                             const FXTEXT_CHARPOS* pCharPos,
                                             CFX_Font* pFont,
                                             CFX_FontCache* pCache,
                                             const CFX_Matrix* pObject2Device,
                                             FX_FIXFLOAT font_size,
                                             FX_DWORD color,
                                             int alpha_flag,
                                             void* pIccTransform) {
  return m_pAggDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
                                      pObject2Device, font_size, color,
                                      alpha_flag, pIccTransform);
}
int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id) {
  return m_pAggDriver->GetDeviceCaps(caps_id);
}
void CFX_SkiaDeviceDriver::SaveState() {
  m_pAggDriver->SaveState();
}

void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
  m_pAggDriver->RestoreState(bKeepSaved);
}
void CFX_SkiaDeviceDriver::SetClipMask(rasterizer_scanline_aa& rasterizer) {
  m_pAggDriver->SetClipMask(rasterizer);
}
void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint) {
  SkIRect clip_box;
  clip_box.set(0, 0, fix0_to_8(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
               fix0_to_8(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
  clip_box.intersect(m_pAggDriver->m_pClipRgn->GetBox().left,
                     m_pAggDriver->m_pClipRgn->GetBox().top,
                     m_pAggDriver->m_pClipRgn->GetBox().right,
                     m_pAggDriver->m_pClipRgn->GetBox().bottom);

  SkPath* pathPtr = &skPath;

  SkRect path_rect = skPath.getBounds();

  clip_box.intersect(FXSYS_floor(path_rect.fLeft), FXSYS_floor(path_rect.fTop),
                     FXSYS_floor(path_rect.fRight) + 1,
                     FXSYS_floor(path_rect.fBottom) + 1);
  CFX_DIBitmapRef mask;
  CFX_DIBitmap* pThisLayer = mask.New();
  pThisLayer->Create(clip_box.width(), clip_box.height(), FXDIB_8bppMask);
  pThisLayer->Clear(0);

  CFX_SkiaA8Renderer render;
  render.Init(pThisLayer, clip_box.fLeft, clip_box.fTop);

  SkRasterClip rasterClip(clip_box);
  SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, *spaint);

  // Finally, we have got the mask that we need, intersect with current clip
  // region
  m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop, mask);
}
FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(
    const CFX_PathData* pPathData,     // path info
    const CFX_Matrix* pObject2Device,  // optional transformation
    int fill_mode                      // fill mode, WINDING or ALTERNATE
    ) {
  if (!m_pAggDriver->m_pClipRgn) {
    m_pAggDriver->m_pClipRgn = new CFX_ClipRgn(
        GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
  }

  if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
    CFX_FloatRect rectf;
    if (pPathData->IsRect(pObject2Device, &rectf)) {
      rectf.Intersect(
          CFX_FloatRect(0, 0, (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                        (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
      FX_RECT rect = rectf.GetOutterRect();
      m_pAggDriver->m_pClipRgn->IntersectRect(rect);
      return TRUE;
    }
  }
  CSkia_PathData path_data;
  path_data.BuildPath(pPathData, pObject2Device);
  path_data.m_PathData.close();
  path_data.m_PathData.setFillType((fill_mode & 3) == FXFILL_WINDING
                                       ? SkPath::kWinding_FillType
                                       : SkPath::kEvenOdd_FillType);

  SkPaint spaint;
  spaint.setColor(0xffffffff);
  spaint.setAntiAlias(TRUE);
  spaint.setStyle(SkPaint::kFill_Style);

  SetClipMask(path_data.m_PathData, &spaint);

  return TRUE;
}

FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(
    const CFX_PathData* pPathData,         // path info
    const CFX_Matrix* pObject2Device,      // optional transformation
    const CFX_GraphStateData* pGraphState  // graphic state, for pen attributes
    ) {
  if (!m_pAggDriver->m_pClipRgn) {
    m_pAggDriver->m_pClipRgn = new CFX_ClipRgn(
        GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
  }

  // build path data
  CSkia_PathData path_data;
  path_data.BuildPath(pPathData, NULL);
  path_data.m_PathData.setFillType(SkPath::kWinding_FillType);

  SkPaint spaint;
  spaint.setColor(0xffffffff);
  spaint.setStyle(SkPaint::kStroke_Style);
  spaint.setAntiAlias(TRUE);

  SkPath dst_path;
  SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device,
                    pGraphState, 1, FALSE, 0);
  spaint.setStyle(SkPaint::kFill_Style);
  SetClipMask(dst_path, &spaint);

  return TRUE;
}
FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(
    rasterizer_scanline_aa& rasterizer,
    FX_DWORD color,
    FX_BOOL bFullCover,
    FX_BOOL bGroupKnockout,
    int alpha_flag,
    void* pIccTransform) {
  return m_pAggDriver->RenderRasterizer(
      rasterizer, color, bFullCover, bGroupKnockout, alpha_flag, pIccTransform);
}
FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath,
                                                   const SkPaint& origPaint,
                                                   SkIRect& rect,
                                                   FX_DWORD color,
                                                   FX_BOOL bFullCover,
                                                   FX_BOOL bGroupKnockout,
                                                   int alpha_flag,
                                                   void* pIccTransform,
                                                   FX_BOOL bFill) {
  CFX_DIBitmap* pt = bGroupKnockout ? m_pAggDriver->GetBackDrop() : NULL;
  CFX_SkiaRenderer render;
  if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn, color,
                   bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag,
                   pIccTransform))
    return FALSE;

  SkRasterClip rasterClip(rect);
  SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip,
                              origPaint);

  return TRUE;
}

FX_BOOL CFX_SkiaDeviceDriver::DrawPath(
    const CFX_PathData* pPathData,          // path info
    const CFX_Matrix* pObject2Device,       // optional transformation
    const CFX_GraphStateData* pGraphState,  // graphic state, for pen attributes
    FX_DWORD fill_color,                    // fill color
    FX_DWORD stroke_color,                  // stroke color
    int fill_mode,  // fill mode, WINDING or ALTERNATE. 0 for not filled
    int alpha_flag,
    void* pIccTransform) {
  if (!GetBuffer())
    return TRUE;
  FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering");
  SkIRect rect;
  rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
           GetDeviceCaps(FXDC_PIXEL_HEIGHT));
  if ((fill_mode & 3) && fill_color) {
    // We have to transform before building path data, otherwise we'll have
    // flatting problem
    // when we enlarge a small path (flatten before transformed)
    // TESTDOC: Bug #5115 - DS_S1Dimpact_lr.pdf
    // build path data
    CSkia_PathData path_data;
    path_data.BuildPath(pPathData, pObject2Device);
    // path_data.m_PathData.close();
    path_data.m_PathData.setFillType((fill_mode & 3) == FXFILL_WINDING
                                         ? SkPath::kWinding_FillType
                                         : SkPath::kEvenOdd_FillType);

    SkPaint spaint;
    spaint.setAntiAlias(TRUE);
    spaint.setStyle(SkPaint::kFill_Style);
    spaint.setColor(fill_color);
    if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fill_color,
                              fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag,
                              pIccTransform))
      return FALSE;
  }

  int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag)
                         ? FXGETFLAG_ALPHA_STROKE(alpha_flag)
                         : FXARGB_A(stroke_color);

  if (pGraphState && stroke_alpha) {
    // We split the matrix into two parts: first part doing the scaling, so we
    // won't have the
    // flatness problem, second part doing the transformation, so we don't have
    // stroking geo problem.
    // TESTDOC: Bug #5253 - test[1].pdf
    CFX_Matrix matrix1, matrix2;
    if (pObject2Device) {
      matrix1.a = FXSYS_fabs(pObject2Device->a) > FXSYS_fabs(pObject2Device->b)
                      ? FXSYS_fabs(pObject2Device->a)
                      : FXSYS_fabs(pObject2Device->b);
      matrix1.d = matrix1.a;  // FXSYS_fabs(pObject2Device->c) >
                              // FXSYS_fabs(pObject2Device->d) ?
      // pObject2Device->c : pObject2Device->d;
      matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a,
                  pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d,
                  pObject2Device->e, pObject2Device->f);
    }
    // build path data
    CSkia_PathData path_data;
    path_data.BuildPath(pPathData, &matrix1);
    path_data.m_PathData.setFillType(SkPath::kWinding_FillType);

    SkPaint spaint;
    spaint.setColor(stroke_color);
    spaint.setStyle(SkPaint::kStroke_Style);
    spaint.setAntiAlias(TRUE);
    SkPath dst_path;
    SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2,
                      pGraphState, matrix1.a, FALSE, 0);
    spaint.setStyle(SkPaint::kFill_Style);
    int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 |
                    FXGETFLAG_ALPHA_STROKE(alpha_flag);

    if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color,
                              fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag,
                              pIccTransform, FALSE))
      return FALSE;
  }

  return TRUE;
}

FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x,
                                       int y,
                                       FX_DWORD color,
                                       int alpha_flag,
                                       void* pIccTransform) {
  return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
}

FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect,
                                       FX_DWORD fill_color,
                                       int alpha_flag,
                                       void* pIccTransform) {
  return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform);
}

FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect) {
  return m_pAggDriver->GetClipBox(pRect);
}

FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
                                        int left,
                                        int top,
                                        void* pIccTransform,
                                        FX_BOOL bDEdge) {
  return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge);
}

FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                        FX_DWORD argb,
                                        const FX_RECT* pSrcRect,
                                        int left,
                                        int top,
                                        int blend_type,
                                        int alpha_flag,
                                        void* pIccTransform) {
  return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend_type,
                                 alpha_flag, pIccTransform);
}

FX_BOOL CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                            FX_DWORD argb,
                                            int dest_left,
                                            int dest_top,
                                            int dest_width,
                                            int dest_height,
                                            const FX_RECT* pClipRect,
                                            FX_DWORD flags,
                                            int alpha_flag,
                                            void* pIccTransform) {
  return m_pAggDriver->StretchDIBits(pSource, argb, dest_left, dest_top,
                                     dest_width, dest_height, pClipRect, flags,
                                     alpha_flag, pIccTransform);
}

FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                          int bitmap_alpha,
                                          FX_DWORD argb,
                                          const CFX_Matrix* pMatrix,
                                          FX_DWORD render_flags,
                                          void*& handle,
                                          int alpha_flag,
                                          void* pIccTransform) {
  return m_pAggDriver->StartDIBits(pSource, bitmap_alpha, argb, pMatrix,
                                   render_flags, handle, alpha_flag,
                                   pIccTransform);
}

FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
  return m_pAggDriver->ContinueDIBits(pHandle, pPause);
}

void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle) {
  m_pAggDriver->CancelDIBits(pHandle);
}

CFX_SkiaDevice::CFX_SkiaDevice() {
  m_bOwnedBitmap = FALSE;
}

FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap,
                               int dither_bits,
                               FX_BOOL bRgbByteOrder,
                               CFX_DIBitmap* pOriDevice,
                               FX_BOOL bGroupKnockout) {
  if (!pBitmap)
    return FALSE;
  SetBitmap(pBitmap);
  CFX_SkiaDeviceDriver* pDriver = new CFX_SkiaDeviceDriver(
      pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
  SetDeviceDriver(pDriver);
  return TRUE;
}

FX_BOOL CFX_SkiaDevice::Create(int width,
                               int height,
                               FXDIB_Format format,
                               int dither_bits,
                               CFX_DIBitmap* pOriDevice) {
  m_bOwnedBitmap = TRUE;
  CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
  if (!pBitmap->Create(width, height, format)) {
    delete pBitmap;
    return FALSE;
  }
  SetBitmap(pBitmap);
  CFX_SkiaDeviceDriver* pDriver =
      new CFX_SkiaDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
  SetDeviceDriver(pDriver);
  return TRUE;
}
CFX_SkiaDevice::~CFX_SkiaDevice() {
  if (m_bOwnedBitmap && GetBitmap())
    delete GetBitmap();
}

#endif