Home | History | Annotate | Download | only in effects 
      1 #include "SkKernel33MaskFilter.h"
      2 #include "SkColorPriv.h"
      3 
      4 SkMask::Format SkKernel33ProcMaskFilter::getFormat()
      5 {
      6     return SkMask::kA8_Format;
      7 }
      8 
      9 bool SkKernel33ProcMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, SkIPoint* margin)
     10 {
     11     // margin???
     12     dst->fImage = NULL;
     13     dst->fBounds = src.fBounds;
     14     dst->fBounds.inset(-1, -1);
     15     dst->fFormat = SkMask::kA8_Format;
     16 
     17     if (NULL == src.fImage)
     18         return true;
     19 
     20     dst->fRowBytes = dst->fBounds.width();
     21     size_t size = dst->computeImageSize();
     22     if (0 == size) {
     23         return false;   // too big to allocate, abort
     24     }
     25     dst->fImage = SkMask::AllocImage(size);
     26 
     27     const int h = src.fBounds.height();
     28     const int w = src.fBounds.width();
     29     const int srcRB = src.fRowBytes;
     30     const uint8_t* srcImage = src.fImage;
     31     uint8_t* dstImage = dst->fImage;
     32 
     33     uint8_t* srcRows[3];
     34     uint8_t storage[3][3];
     35 
     36     srcRows[0] = storage[0];
     37     srcRows[1] = storage[1];
     38     srcRows[2] = storage[2];
     39 
     40     unsigned scale = fPercent256;
     41 
     42     for (int y = -1; y <= h; y++)
     43     {
     44         uint8_t* dstRow = dstImage;
     45         for (int x = -1; x <= w; x++)
     46         {
     47             memset(storage, 0, sizeof(storage));
     48             uint8_t* storagePtr = &storage[0][0];
     49 
     50             for (int ky = y - 1; ky <= y + 1; ky++)
     51             {
     52                 const uint8_t* srcRow = srcImage + ky * srcRB;  // may be out-of-range
     53                 for (int kx = x - 1; kx <= x + 1; kx++)
     54                 {
     55                     if ((unsigned)ky < (unsigned)h && (unsigned)kx < (unsigned)w)
     56                         *storagePtr = srcRow[kx];
     57                     storagePtr++;
     58                 }
     59             }
     60             int value = this->computeValue(srcRows);
     61 
     62             if (scale < 256)
     63                 value = SkAlphaBlend(value, srcRows[1][1], scale);
     64             *dstRow++ = SkToU8(value);
     65         }
     66         dstImage += dst->fRowBytes;
     67     }
     68     return true;
     69 }
     70 
     71 void SkKernel33ProcMaskFilter::flatten(SkFlattenableWriteBuffer& wb)
     72 {
     73     this->INHERITED::flatten(wb);
     74     wb.write32(fPercent256);
     75 }
     76 
     77 SkKernel33ProcMaskFilter::SkKernel33ProcMaskFilter(SkFlattenableReadBuffer& rb)
     78     : SkMaskFilter(rb)
     79 {
     80     fPercent256 = rb.readS32();
     81 }
     82 
     83 ///////////////////////////////////////////////////////////////////////////////
     84 
     85 uint8_t SkKernel33MaskFilter::computeValue(uint8_t* const* srcRows)
     86 {
     87     int value = 0;
     88 
     89     for (int i = 0; i < 3; i++)
     90         for (int j = 0; j < 3; j++)
     91             value += fKernel[i][j] * srcRows[i][j];
     92 
     93     value >>= fShift;
     94 
     95     if (value < 0)
     96         value = 0;
     97     else if (value > 255)
     98         value = 255;
     99     return (uint8_t)value;
    100 }
    101 
    102 void SkKernel33MaskFilter::flatten(SkFlattenableWriteBuffer& wb)
    103 {
    104     this->INHERITED::flatten(wb);
    105     wb.writeMul4(fKernel, 9 * sizeof(int));
    106     wb.write32(fShift);
    107 }
    108 
    109 SkFlattenable::Factory SkKernel33MaskFilter::getFactory()
    110 {
    111     return Create;
    112 }
    113 
    114 SkFlattenable* SkKernel33MaskFilter::Create(SkFlattenableReadBuffer& rb)
    115 {
    116     return new SkKernel33MaskFilter(rb);
    117 }
    118 
    119 SkKernel33MaskFilter::SkKernel33MaskFilter(SkFlattenableReadBuffer& rb)
    120     : SkKernel33ProcMaskFilter(rb)
    121 {
    122     rb.read(fKernel, 9 * sizeof(int));
    123     fShift = rb.readS32();
    124 }
    125 
    126