LCOV - app.info - gfx/skia/src/core/SkShader.cpp

LCOV - code coverage report
| Current view: | directory - gfx/skia/src/core - SkShader.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 196 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 43 | 0 | 0.0 %

           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 "SkScalar.h"
          11                 : #include "SkShader.h"
          12                 : #include "SkPaint.h"
          13                 : #include "SkMallocPixelRef.h"
          14                 :
          15               0 : SkShader::SkShader() : fLocalMatrix(NULL) {
          16               0 :     SkDEBUGCODE(fInSession = false;)
          17               0 : }
          18                 :
          19               0 : SkShader::SkShader(SkFlattenableReadBuffer& buffer)
          20               0 :         : INHERITED(buffer), fLocalMatrix(NULL) {
          21               0 :     if (buffer.readBool()) {
          22                 :         SkMatrix matrix;
          23               0 :         SkReadMatrix(&buffer, &matrix);
          24               0 :         setLocalMatrix(matrix);
          25                 :     }
          26               0 :     SkDEBUGCODE(fInSession = false;)
          27               0 : }
          28                 :
          29               0 : SkShader::~SkShader() {
          30               0 :     SkASSERT(!fInSession);
          31               0 :     sk_free(fLocalMatrix);
          32               0 : }
          33                 :
          34               0 : void SkShader::beginSession() {
          35               0 :     SkASSERT(!fInSession);
          36               0 :     SkDEBUGCODE(fInSession = true;)
          37               0 : }
          38                 :
          39               0 : void SkShader::endSession() {
          40               0 :     SkASSERT(fInSession);
          41               0 :     SkDEBUGCODE(fInSession = false;)
          42               0 : }
          43                 :
          44               0 : void SkShader::flatten(SkFlattenableWriteBuffer& buffer) {
          45               0 :     this->INHERITED::flatten(buffer);
          46               0 :     buffer.writeBool(fLocalMatrix != NULL);
          47               0 :     if (fLocalMatrix) {
          48               0 :         SkWriteMatrix(&buffer, *fLocalMatrix);
          49                 :     }
          50               0 : }
          51                 :
          52               0 : bool SkShader::getLocalMatrix(SkMatrix* localM) const {
          53               0 :     if (fLocalMatrix) {
          54               0 :         if (localM) {
          55               0 :             *localM = *fLocalMatrix;
          56                 :         }
          57               0 :         return true;
          58                 :     } else {
          59               0 :         if (localM) {
          60               0 :             localM->reset();
          61                 :         }
          62               0 :         return false;
          63                 :     }
          64                 : }
          65                 :
          66               0 : void SkShader::setLocalMatrix(const SkMatrix& localM) {
          67               0 :     if (localM.isIdentity()) {
          68               0 :         this->resetLocalMatrix();
          69                 :     } else {
          70               0 :         if (fLocalMatrix == NULL) {
          71               0 :             fLocalMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
          72                 :         }
          73               0 :         *fLocalMatrix = localM;
          74                 :     }
          75               0 : }
          76                 :
          77               0 : void SkShader::resetLocalMatrix() {
          78               0 :     if (fLocalMatrix) {
          79               0 :         sk_free(fLocalMatrix);
          80               0 :         fLocalMatrix = NULL;
          81                 :     }
          82               0 : }
          83                 :
          84               0 : bool SkShader::setContext(const SkBitmap& device,
          85                 :                           const SkPaint& paint,
          86                 :                           const SkMatrix& matrix) {
          87               0 :     const SkMatrix* m = &matrix;
          88                 :     SkMatrix        total;
          89                 :
          90               0 :     fDeviceConfig = SkToU8(device.getConfig());
          91               0 :     fPaintAlpha = paint.getAlpha();
          92               0 :     if (fLocalMatrix) {
          93               0 :         total.setConcat(matrix, *fLocalMatrix);
          94               0 :         m = &total;
          95                 :     }
          96               0 :     if (m->invert(&fTotalInverse)) {
          97               0 :         fTotalInverseClass = (uint8_t)ComputeMatrixClass(fTotalInverse);
          98               0 :         return true;
          99                 :     }
         100               0 :     return false;
         101                 : }
         102                 :
         103                 : #include "SkColorPriv.h"
         104                 :
         105               0 : void SkShader::shadeSpan16(int x, int y, uint16_t span16[], int count) {
         106               0 :     SkASSERT(span16);
         107               0 :     SkASSERT(count > 0);
         108               0 :     SkASSERT(this->canCallShadeSpan16());
         109                 :
         110                 :     // basically, if we get here, the subclass screwed up
         111               0 :     SkDEBUGFAIL("kHasSpan16 flag is set, but shadeSpan16() not implemented");
         112               0 : }
         113                 :
         114                 : #define kTempColorQuadCount 6   // balance between speed (larger) and saving stack-space
         115                 : #define kTempColorCount     (kTempColorQuadCount << 2)
         116                 :
         117                 : #ifdef SK_CPU_BENDIAN
         118                 :     #define SkU32BitShiftToByteOffset(shift)    (3 - ((shift) >> 3))
         119                 : #else
         120                 :     #define SkU32BitShiftToByteOffset(shift)    ((shift) >> 3)
         121                 : #endif
         122                 :
         123               0 : void SkShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
         124               0 :     SkASSERT(count > 0);
         125                 :
         126                 :     SkPMColor   colors[kTempColorCount];
         127                 :
         128               0 :     while ((count -= kTempColorCount) >= 0) {
         129               0 :         this->shadeSpan(x, y, colors, kTempColorCount);
         130               0 :         x += kTempColorCount;
         131                 :
         132               0 :         const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
         133               0 :         int quads = kTempColorQuadCount;
         134               0 :         do {
         135               0 :             U8CPU a0 = srcA[0];
         136               0 :             U8CPU a1 = srcA[4];
         137               0 :             U8CPU a2 = srcA[8];
         138               0 :             U8CPU a3 = srcA[12];
         139               0 :             srcA += 4*4;
         140               0 :             *alpha++ = SkToU8(a0);
         141               0 :             *alpha++ = SkToU8(a1);
         142               0 :             *alpha++ = SkToU8(a2);
         143               0 :             *alpha++ = SkToU8(a3);
         144                 :         } while (--quads != 0);
         145                 :     }
         146               0 :     SkASSERT(count < 0);
         147               0 :     SkASSERT(count + kTempColorCount >= 0);
         148               0 :     if (count += kTempColorCount) {
         149               0 :         this->shadeSpan(x, y, colors, count);
         150                 :
         151               0 :         const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
         152               0 :         do {
         153               0 :             *alpha++ = *srcA;
         154               0 :             srcA += 4;
         155                 :         } while (--count != 0);
         156                 :     }
         157                 : #if 0
         158                 :     do {
         159                 :         int n = count;
         160                 :         if (n > kTempColorCount)
         161                 :             n = kTempColorCount;
         162                 :         SkASSERT(n > 0);
         163                 :
         164                 :         this->shadeSpan(x, y, colors, n);
         165                 :         x += n;
         166                 :         count -= n;
         167                 :
         168                 :         const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
         169                 :         do {
         170                 :             *alpha++ = *srcA;
         171                 :             srcA += 4;
         172                 :         } while (--n != 0);
         173                 :     } while (count > 0);
         174                 : #endif
         175               0 : }
         176                 :
         177               0 : SkShader::MatrixClass SkShader::ComputeMatrixClass(const SkMatrix& mat) {
         178               0 :     MatrixClass mc = kLinear_MatrixClass;
         179                 :
         180               0 :     if (mat.hasPerspective()) {
         181               0 :         if (mat.fixedStepInX(0, NULL, NULL)) {
         182               0 :             mc = kFixedStepInX_MatrixClass;
         183                 :         } else {
         184               0 :             mc = kPerspective_MatrixClass;
         185                 :         }
         186                 :     }
         187               0 :     return mc;
         188                 : }
         189                 :
         190                 : //////////////////////////////////////////////////////////////////////////////
         191                 :
         192               0 : SkShader::BitmapType SkShader::asABitmap(SkBitmap*, SkMatrix*,
         193                 :                                          TileMode*, SkScalar*) const {
         194               0 :     return kNone_BitmapType;
         195                 : }
         196                 :
         197               0 : SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const {
         198               0 :     return kNone_GradientType;
         199                 : }
         200                 :
         201               0 : SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
         202                 :                                        TileMode tmx, TileMode tmy) {
         203               0 :     return SkShader::CreateBitmapShader(src, tmx, tmy, NULL, 0);
         204                 : }
         205                 :
         206                 : //////////////////////////////////////////////////////////////////////////////
         207                 :
         208                 : #include "SkColorShader.h"
         209                 : #include "SkUtils.h"
         210                 :
         211               0 : SkColorShader::SkColorShader() {
         212               0 :     fFlags = 0;
         213               0 :     fInheritColor = true;
         214               0 : }
         215                 :
         216               0 : SkColorShader::SkColorShader(SkColor c) {
         217               0 :     fFlags = 0;
         218               0 :     fColor = c;
         219               0 :     fInheritColor = false;
         220               0 : }
         221                 :
         222               0 : SkColorShader::~SkColorShader() {}
         223                 :
         224               0 : bool SkColorShader::isOpaque() const {
         225               0 :     if (fInheritColor) {
         226               0 :         return true; // using paint's alpha
         227                 :     }
         228               0 :     return SkColorGetA(fColor) == 255;
         229                 : }
         230                 :
         231               0 : SkColorShader::SkColorShader(SkFlattenableReadBuffer& b) : INHERITED(b) {
         232               0 :     fFlags = 0; // computed in setContext
         233                 :
         234               0 :     fInheritColor = b.readU8();
         235               0 :     if (fInheritColor) {
         236               0 :         return;
         237                 :     }
         238               0 :     fColor = b.readU32();
         239                 : }
         240                 :
         241               0 : void SkColorShader::flatten(SkFlattenableWriteBuffer& buffer) {
         242               0 :     this->INHERITED::flatten(buffer);
         243               0 :     buffer.write8(fInheritColor);
         244               0 :     if (fInheritColor) {
         245               0 :         return;
         246                 :     }
         247               0 :     buffer.write32(fColor);
         248                 : }
         249                 :
         250               0 : SkFlattenable* SkColorShader::CreateProc(SkFlattenableReadBuffer& buffer) {
         251               0 :     return SkNEW_ARGS(SkColorShader, (buffer));
         252                 : }
         253                 :
         254               0 : SkFlattenable::Factory SkColorShader::getFactory() {
         255               0 :     return CreateProc;
         256                 : }
         257                 :
         258               0 : uint32_t SkColorShader::getFlags() {
         259               0 :     return fFlags;
         260                 : }
         261                 :
         262               0 : uint8_t SkColorShader::getSpan16Alpha() const {
         263               0 :     return SkGetPackedA32(fPMColor);
         264                 : }
         265                 :
         266               0 : bool SkColorShader::setContext(const SkBitmap& device, const SkPaint& paint,
         267                 :                                const SkMatrix& matrix) {
         268               0 :     if (!this->INHERITED::setContext(device, paint, matrix)) {
         269               0 :         return false;
         270                 :     }
         271                 :
         272                 :     unsigned a;
         273                 :
         274               0 :     if (fInheritColor) {
         275               0 :         fColor = paint.getColor();
         276               0 :         a = SkColorGetA(fColor);
         277                 :     } else {
         278               0 :         a = SkAlphaMul(SkColorGetA(fColor), SkAlpha255To256(paint.getAlpha()));
         279                 :     }
         280                 :
         281               0 :     unsigned r = SkColorGetR(fColor);
         282               0 :     unsigned g = SkColorGetG(fColor);
         283               0 :     unsigned b = SkColorGetB(fColor);
         284                 :
         285                 :     // we want this before we apply any alpha
         286               0 :     fColor16 = SkPack888ToRGB16(r, g, b);
         287                 :
         288               0 :     if (a != 255) {
         289               0 :         r = SkMulDiv255Round(r, a);
         290               0 :         g = SkMulDiv255Round(g, a);
         291               0 :         b = SkMulDiv255Round(b, a);
         292                 :     }
         293               0 :     fPMColor = SkPackARGB32(a, r, g, b);
         294                 :
         295               0 :     fFlags = kConstInY32_Flag;
         296               0 :     if (255 == a) {
         297               0 :         fFlags |= kOpaqueAlpha_Flag;
         298               0 :         if (paint.isDither() == false) {
         299               0 :             fFlags |= kHasSpan16_Flag;
         300                 :         }
         301                 :     }
         302                 :
         303               0 :     return true;
         304                 : }
         305                 :
         306               0 : void SkColorShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
         307               0 :     sk_memset32(span, fPMColor, count);
         308               0 : }
         309                 :
         310               0 : void SkColorShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
         311               0 :     sk_memset16(span, fColor16, count);
         312               0 : }
         313                 :
         314               0 : void SkColorShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
         315               0 :     memset(alpha, SkGetPackedA32(fPMColor), count);
         316               0 : }
         317                 :
         318                 : // if we had a asAColor method, that would be more efficient...
         319               0 : SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
         320                 :                                               TileMode modes[],
         321                 :                                       SkScalar* twoPointRadialParams) const {
         322               0 :     return kNone_BitmapType;
         323                 : }
         324                 :
         325               0 : SkShader::GradientType SkColorShader::asAGradient(GradientInfo* info) const {
         326               0 :     if (info) {
         327               0 :         if (info->fColors && info->fColorCount >= 1) {
         328               0 :             info->fColors[0] = fColor;
         329                 :         }
         330               0 :         info->fColorCount = 1;
         331               0 :         info->fTileMode = SkShader::kRepeat_TileMode;
         332                 :     }
         333               0 :     return kColor_GradientType;
         334                 : }
         335                 :
         336                 : ///////////////////////////////////////////////////////////////////////////////
         337                 :
         338                 : #include "SkEmptyShader.h"
         339                 :
         340               0 : SkEmptyShader::SkEmptyShader(SkFlattenableReadBuffer& b) : INHERITED(b) {}
         341                 :
         342               0 : uint32_t SkEmptyShader::getFlags() { return 0; }
         343               0 : uint8_t SkEmptyShader::getSpan16Alpha() const { return 0; }
         344                 :
         345               0 : bool SkEmptyShader::setContext(const SkBitmap&, const SkPaint&,
         346               0 :                                const SkMatrix&) { return false; }
         347                 :
         348               0 : void SkEmptyShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
         349               0 :     SkDEBUGFAIL("should never get called, since setContext() returned false");
         350               0 : }
         351                 :
         352               0 : void SkEmptyShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
         353               0 :     SkDEBUGFAIL("should never get called, since setContext() returned false");
         354               0 : }
         355                 :
         356               0 : void SkEmptyShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
         357               0 :     SkDEBUGFAIL("should never get called, since setContext() returned false");
         358               0 : }
         359                 :
         360               0 : SkFlattenable::Factory SkEmptyShader::getFactory() { return NULL; }
         361                 :
         362               0 : void SkEmptyShader::flatten(SkFlattenableWriteBuffer& buffer) {
         363               0 :     this->INHERITED::flatten(buffer);
         364               0 : }
         365                 :

Generated by: LCOV version 1.7