LCOV - code coverage report
Current view: directory - gfx/skia/src/effects - SkLayerRasterizer.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 119 1 0.8 %
Date: 2012-06-02 Functions: 15 2 13.3 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #include "SkLayerRasterizer.h"
      11                 : #include "SkBuffer.h"
      12                 : #include "SkDraw.h"
      13                 : #include "SkMask.h"
      14                 : #include "SkMaskFilter.h"
      15                 : #include "SkPaint.h"
      16                 : #include "SkPath.h"
      17                 : #include "../core/SkRasterClip.h"
      18                 : #include "SkXfermode.h"
      19                 : #include <new>
      20                 : 
      21                 : struct SkLayerRasterizer_Rec {
      22                 :     SkPaint     fPaint;
      23                 :     SkVector    fOffset;
      24                 : };
      25                 : 
      26               0 : SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec))
      27                 : {
      28               0 : }
      29                 : 
      30               0 : SkLayerRasterizer::~SkLayerRasterizer() {
      31               0 :     SkDeque::F2BIter        iter(fLayers);
      32                 :     SkLayerRasterizer_Rec*  rec;
      33                 : 
      34               0 :     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
      35               0 :         rec->fPaint.~SkPaint();
      36               0 : }
      37                 : 
      38               0 : void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx,
      39                 :                                  SkScalar dy) {
      40               0 :     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
      41                 : 
      42               0 :     new (&rec->fPaint) SkPaint(paint);
      43               0 :     rec->fOffset.set(dx, dy);
      44               0 : }
      45                 : 
      46               0 : static bool compute_bounds(const SkDeque& layers, const SkPath& path,
      47                 :                            const SkMatrix& matrix,
      48                 :                            const SkIRect* clipBounds, SkIRect* bounds) {
      49               0 :     SkDeque::F2BIter        iter(layers);
      50                 :     SkLayerRasterizer_Rec*  rec;
      51                 : 
      52               0 :     bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
      53                 : 
      54               0 :     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
      55               0 :         const SkPaint&  paint = rec->fPaint;
      56               0 :         SkPath          fillPath, devPath;
      57               0 :         const SkPath*   p = &path;
      58                 : 
      59               0 :         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
      60               0 :             paint.getFillPath(path, &fillPath);
      61               0 :             p = &fillPath;
      62                 :         }
      63               0 :         if (p->isEmpty()) {
      64               0 :             continue;
      65                 :         }
      66                 : 
      67                 :         // apply the matrix and offset
      68                 :         {
      69               0 :             SkMatrix m = matrix;
      70               0 :             m.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
      71               0 :             p->transform(m, &devPath);
      72                 :         }
      73                 : 
      74                 :         SkMask  mask;
      75               0 :         if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(),
      76                 :                                 &matrix, &mask,
      77               0 :                                 SkMask::kJustComputeBounds_CreateMode)) {
      78               0 :             return false;
      79                 :         }
      80                 : 
      81               0 :         bounds->join(mask.fBounds);
      82                 :     }
      83               0 :     return true;
      84                 : }
      85                 : 
      86               0 : bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
      87                 :                                     const SkIRect* clipBounds,
      88                 :                                     SkMask* mask, SkMask::CreateMode mode) {
      89               0 :     if (fLayers.empty()) {
      90               0 :         return false;
      91                 :     }
      92                 : 
      93               0 :     if (SkMask::kJustRenderImage_CreateMode != mode) {
      94               0 :         if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds))
      95               0 :             return false;
      96                 :     }
      97                 : 
      98               0 :     if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
      99               0 :         mask->fFormat   = SkMask::kA8_Format;
     100               0 :         mask->fRowBytes = mask->fBounds.width();
     101               0 :         size_t size = mask->computeImageSize();
     102               0 :         if (0 == size) {
     103               0 :             return false;   // too big to allocate, abort
     104                 :         }
     105               0 :         mask->fImage = SkMask::AllocImage(size);
     106               0 :         memset(mask->fImage, 0, size);
     107                 :     }
     108                 : 
     109               0 :     if (SkMask::kJustComputeBounds_CreateMode != mode) {
     110               0 :         SkBitmap        device;
     111               0 :         SkRasterClip    rectClip;
     112               0 :         SkDraw          draw;
     113                 :         SkMatrix        translatedMatrix;  // this translates us to our local pixels
     114                 :         SkMatrix        drawMatrix;        // this translates the path by each layer's offset
     115                 : 
     116               0 :         rectClip.setRect(SkIRect::MakeWH(mask->fBounds.width(), mask->fBounds.height()));
     117                 : 
     118               0 :         translatedMatrix = matrix;
     119               0 :         translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
     120               0 :                                        -SkIntToScalar(mask->fBounds.fTop));
     121                 : 
     122               0 :         device.setConfig(SkBitmap::kA8_Config, mask->fBounds.width(), mask->fBounds.height(), mask->fRowBytes);
     123               0 :         device.setPixels(mask->fImage);
     124                 : 
     125               0 :         draw.fBitmap    = &device;
     126               0 :         draw.fMatrix    = &drawMatrix;
     127               0 :         draw.fRC        = &rectClip;
     128               0 :         draw.fClip      = &rectClip.bwRgn();
     129                 :         // we set the matrixproc in the loop, as the matrix changes each time (potentially)
     130               0 :         draw.fBounder   = NULL;
     131                 : 
     132               0 :         SkDeque::F2BIter        iter(fLayers);
     133                 :         SkLayerRasterizer_Rec*  rec;
     134                 : 
     135               0 :         while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
     136               0 :             drawMatrix = translatedMatrix;
     137               0 :             drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
     138               0 :             draw.drawPath(path, rec->fPaint);
     139                 :         }
     140                 :     }
     141               0 :     return true;
     142                 : }
     143                 : 
     144                 : /////////// Routines for flattening /////////////////
     145                 : 
     146               0 : static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer) {
     147               0 :     paint->setAntiAlias(buffer.readBool());
     148               0 :     paint->setStyle((SkPaint::Style)buffer.readU8());
     149               0 :     paint->setAlpha(buffer.readU8());
     150                 : 
     151               0 :     if (paint->getStyle() != SkPaint::kFill_Style) {
     152               0 :         paint->setStrokeWidth(buffer.readScalar());
     153               0 :         paint->setStrokeMiter(buffer.readScalar());
     154               0 :         paint->setStrokeCap((SkPaint::Cap)buffer.readU8());
     155               0 :         paint->setStrokeJoin((SkPaint::Join)buffer.readU8());
     156                 :     }
     157                 : 
     158               0 :     SkSafeUnref(paint->setMaskFilter((SkMaskFilter*)buffer.readFlattenable()));
     159               0 :     SkSafeUnref(paint->setPathEffect((SkPathEffect*)buffer.readFlattenable()));
     160               0 :     SkSafeUnref(paint->setRasterizer((SkRasterizer*)buffer.readFlattenable()));
     161               0 :     SkSafeUnref(paint->setXfermode((SkXfermode*)buffer.readFlattenable()));
     162               0 : }
     163                 : 
     164               0 : static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer) {
     165               0 :     buffer.writeBool(paint.isAntiAlias());
     166               0 :     buffer.write8(paint.getStyle());
     167               0 :     buffer.write8(paint.getAlpha());
     168                 : 
     169               0 :     if (paint.getStyle() != SkPaint::kFill_Style) {
     170               0 :         buffer.writeScalar(paint.getStrokeWidth());
     171               0 :         buffer.writeScalar(paint.getStrokeMiter());
     172               0 :         buffer.write8(paint.getStrokeCap());
     173               0 :         buffer.write8(paint.getStrokeJoin());
     174                 :     }
     175                 : 
     176               0 :     buffer.writeFlattenable(paint.getMaskFilter());
     177               0 :     buffer.writeFlattenable(paint.getPathEffect());
     178               0 :     buffer.writeFlattenable(paint.getRasterizer());
     179               0 :     buffer.writeFlattenable(paint.getXfermode());
     180               0 : }
     181                 : 
     182               0 : SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
     183               0 :     : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) {
     184               0 :     int count = buffer.readS32();
     185                 : 
     186               0 :     for (int i = 0; i < count; i++) {
     187               0 :         SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
     188                 : 
     189                 : #if 0
     190                 :         new (&rec->fPaint) SkPaint(buffer);
     191                 : #else
     192               0 :         new (&rec->fPaint) SkPaint;
     193               0 :         paint_read(&rec->fPaint, buffer);
     194                 : #endif
     195               0 :         rec->fOffset.fX = buffer.readScalar();
     196               0 :         rec->fOffset.fY = buffer.readScalar();
     197                 :     }
     198               0 : }
     199                 : 
     200               0 : void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) {
     201               0 :     this->INHERITED::flatten(buffer);
     202                 : 
     203               0 :     buffer.write32(fLayers.count());
     204                 : 
     205               0 :     SkDeque::F2BIter                iter(fLayers);
     206                 :     const SkLayerRasterizer_Rec*    rec;
     207                 : 
     208               0 :     while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
     209                 : #if 0
     210                 :         rec->fPaint.flatten(buffer);
     211                 : #else
     212               0 :         paint_write(rec->fPaint, buffer);
     213                 : #endif
     214               0 :         buffer.writeScalar(rec->fOffset.fX);
     215               0 :         buffer.writeScalar(rec->fOffset.fY);
     216                 :     }
     217               0 : }
     218                 : 
     219               0 : SkFlattenable* SkLayerRasterizer::CreateProc(SkFlattenableReadBuffer& buffer) {
     220               0 :     return SkNEW_ARGS(SkLayerRasterizer, (buffer));
     221                 : }
     222                 : 
     223               0 : SkFlattenable::Factory SkLayerRasterizer::getFactory() {
     224               0 :     return CreateProc;
     225                 : }
     226                 : 
     227            2928 : SK_DEFINE_FLATTENABLE_REGISTRAR(SkLayerRasterizer)
     228                 : 

Generated by: LCOV version 1.7