SkAAClip.cpp File Reference

#include "src/core/SkAAClip.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkPath.h"
#include "include/core/SkRegion.h"
#include "include/core/SkTypes.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMacros.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTDArray.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkBlitter.h"
#include "src/core/SkMask.h"
#include "src/core/SkScan.h"
#include <algorithm>
#include <atomic>
#include <cstring>

Go to the source code of this file.

Classes
struct	SkAAClip::RunHead
class	SkAAClip::Builder
class	SkAAClip::Builder::Blitter

Macros
#define	AUTO_AACLIP_VALIDATE(clip)

Typedefs
typedef void(*	MergeAAProc) (const void *src, int width, const uint8_t *row, int initialRowCount, void *dst)

Functions
static void	count_left_right_zeros (const uint8_t *row, int width, int *leftZ, int *riteZ)
static int	trim_row_left_right (uint8_t *row, int width, int leftZ, int riteZ)
static bool	row_is_all_zeros (const uint8_t *row, int width)
static void	expandToRuns (const uint8_t *SK_RESTRICT data, int initialCount, int width, int16_t *SK_RESTRICT runs, SkAlpha *SK_RESTRICT aa)
static void	merge (const uint8_t *SK_RESTRICT row, int rowN, const SkAlpha *SK_RESTRICT srcAA, const int16_t *SK_RESTRICT srcRuns, SkAlpha *SK_RESTRICT dstAA, int16_t *SK_RESTRICT dstRuns, int width)
static void	small_memcpy (void *dst, const void *src, size_t n)
static void	small_bzero (void *dst, size_t n)
static uint8_t	mergeOne (uint8_t value, unsigned alpha)
static uint16_t	mergeOne (uint16_t value, unsigned alpha)
template<typename T >
void	mergeT (const void *inSrc, int srcN, const uint8_t *SK_RESTRICT row, int rowN, void *inDst)
static MergeAAProc	find_merge_aa_proc (SkMask::Format format)
static U8CPU	bit2byte (int bitInAByte)
static void	upscaleBW2A8 (SkMask *dstMask, const SkMask &srcMask)

Macro Definition Documentation

AUTO_AACLIP_VALIDATE

#define AUTO_AACLIP_VALIDATE

(

clip

)

Definition at line 47 of file SkAAClip.cpp.

Typedef Documentation

MergeAAProc

typedef void(* MergeAAProc) (const void *src, int width, const uint8_t *row, int initialRowCount, void *dst)

Definition at line 1788 of file SkAAClip.cpp.

Function Documentation

bit2byte()

static U8CPU bit2byte ( int  bitInAByte )

static

Definition at line 1861 of file SkAAClip.cpp.

                                      {
    SkASSERT(bitInAByte <= 0xFF);
    // negation turns any non-zero into 0xFFFFFF??, so we just shift down
    // some value >= 8 to get a full FF value
    return -bitInAByte >> 8;
}

count_left_right_zeros()

static void count_left_right_zeros ( const uint8_t *  row, int  width, int *  leftZ, int *  riteZ  )

static

Definition at line 972 of file SkAAClip.cpp.

                                                           {
    int zeros = 0;
    do {
        if (row[1]) {
            break;
        }
        int n = row[0];
        SkASSERT(n > 0);
        SkASSERT(n <= width);
        zeros += n;
        row += 2;
        width -= n;
    } while (width > 0);
    *leftZ = zeros;
 
    if (0 == width) {
        // this line is completely empty return 'width' in both variables
        *riteZ = *leftZ;
        return;
    }
 
    zeros = 0;
    while (width > 0) {
        int n = row[0];
        SkASSERT(n > 0);
        if (0 == row[1]) {
            zeros += n;
        } else {
            zeros = 0;
        }
        row += 2;
        width -= n;
    }
    *riteZ = zeros;
}

expandToRuns()

static void expandToRuns ( const uint8_t *SK_RESTRICT  data, int  initialCount, int  width, int16_t *SK_RESTRICT  runs, SkAlpha *SK_RESTRICT  aa  )

static

Definition at line 1622 of file SkAAClip.cpp.

                                                                             {
    // we don't read our initial n from data, since the caller may have had to
    // clip it, hence the initialCount parameter.
    int n = initialCount;
    for (;;) {
        if (n > width) {
            n = width;
        }
        SkASSERT(n > 0);
        runs[0] = n;
        runs += n;
 
        aa[0] = data[1];
        aa += n;
 
        data += 2;
        width -= n;
        if (0 == width) {
            break;
        }
        // load the next count
        n = data[0];
    }
    runs[0] = 0;    // sentinel
}

find_merge_aa_proc()

static MergeAAProc find_merge_aa_proc ( SkMask::Format  format )

static

Definition at line 1845 of file SkAAClip.cpp.

                                                           {
    switch (format) {
        case SkMask::kBW_Format:
            SkDEBUGFAIL("unsupported");
            return nullptr;
        case SkMask::kA8_Format:
        case SkMask::k3D_Format:
            return mergeT<uint8_t> ;
        case SkMask::kLCD16_Format:
            return mergeT<uint16_t>;
        default:
            SkDEBUGFAIL("unsupported");
            return nullptr;
    }
}

merge()

static void merge ( const uint8_t *SK_RESTRICT  row, int  rowN, const SkAlpha *SK_RESTRICT  srcAA, const int16_t *SK_RESTRICT  srcRuns, SkAlpha *SK_RESTRICT  dstAA, int16_t *SK_RESTRICT  dstRuns, int  width  )

static

Definition at line 1691 of file SkAAClip.cpp.

                             {
    SkDEBUGCODE(int accumulated = 0;)
    int srcN = srcRuns[0];
    // do we need this check?
    if (0 == srcN) {
        return;
    }
 
    for (;;) {
        SkASSERT(rowN > 0);
        SkASSERT(srcN > 0);
 
        unsigned newAlpha = SkMulDiv255Round(srcAA[0], row[1]);
        int minN = std::min(srcN, rowN);
        dstRuns[0] = minN;
        dstRuns += minN;
        dstAA[0] = newAlpha;
        dstAA += minN;
 
        if (0 == (srcN -= minN)) {
            srcN = srcRuns[0];  // refresh
            srcRuns += srcN;
            srcAA += srcN;
            srcN = srcRuns[0];  // reload
            if (0 == srcN) {
                break;
            }
        }
        if (0 == (rowN -= minN)) {
            row += 2;
            rowN = row[0];  // reload
        }
 
        SkDEBUGCODE(accumulated += minN;)
        SkASSERT(accumulated <= width);
    }
    dstRuns[0] = 0;
}

mergeOne() [1/2]

static uint16_t mergeOne ( uint16_t  value, unsigned  alpha  )

inlinestatic

Definition at line 1803 of file SkAAClip.cpp.

                                                                {
    unsigned r = SkGetPackedR16(value);
    unsigned g = SkGetPackedG16(value);
    unsigned b = SkGetPackedB16(value);
    return SkPackRGB16(SkMulDiv255Round(r, alpha),
                       SkMulDiv255Round(g, alpha),
                       SkMulDiv255Round(b, alpha));
}

mergeOne() [2/2]

static uint8_t mergeOne ( uint8_t  value, unsigned  alpha  )

inlinestatic

Definition at line 1799 of file SkAAClip.cpp.

                                                              {
    return SkMulDiv255Round(value, alpha);
}

mergeT()

template<typename T >

void mergeT	(	const void *	inSrc,
		int	srcN,
		const uint8_t *SK_RESTRICT	row,
		int	rowN,
		void *	inDst
	)

Definition at line 1813 of file SkAAClip.cpp.

                                                                                                {
    const T* SK_RESTRICT src = static_cast<const T*>(inSrc);
    T* SK_RESTRICT       dst = static_cast<T*>(inDst);
    for (;;) {
        SkASSERT(rowN > 0);
        SkASSERT(srcN > 0);
 
        int n = std::min(rowN, srcN);
        unsigned rowA = row[1];
        if (0xFF == rowA) {
            small_memcpy(dst, src, n * sizeof(T));
        } else if (0 == rowA) {
            small_bzero(dst, n * sizeof(T));
        } else {
            for (int i = 0; i < n; ++i) {
                dst[i] = mergeOne(src[i], rowA);
            }
        }
 
        if (0 == (srcN -= n)) {
            break;
        }
 
        src += n;
        dst += n;
 
        SkASSERT(rowN == n);
        row += 2;
        rowN = row[0];
    }
}

row_is_all_zeros()

static bool row_is_all_zeros ( const uint8_t *  row, int  width  )

static

Definition at line 1116 of file SkAAClip.cpp.

                                                            {
    SkASSERT(width > 0);
    do {
        if (row[1]) {
            return false;
        }
        int n = row[0];
        SkASSERT(n <= width);
        width -= n;
        row += 2;
    } while (width > 0);
    SkASSERT(0 == width);
    return true;
}

small_bzero()

static void small_bzero ( void *  dst, size_t  n  )

static

Definition at line 1795 of file SkAAClip.cpp.

                                             {
    sk_bzero(dst, n);
}

small_memcpy()

static void small_memcpy ( void *  dst, const void *  src, size_t  n  )

static

Definition at line 1791 of file SkAAClip.cpp.

                                                               {
    memcpy(dst, src, n);
}

trim_row_left_right()

static int trim_row_left_right ( uint8_t *  row, int  width, int  leftZ, int  riteZ  )

static

Definition at line 1011 of file SkAAClip.cpp.

                                                                              {
    int trim = 0;
    while (leftZ > 0) {
        SkASSERT(0 == row[1]);
        int n = row[0];
        SkASSERT(n > 0);
        SkASSERT(n <= width);
        width -= n;
        row += 2;
        if (n > leftZ) {
            row[-2] = n - leftZ;
            break;
        }
        trim += 2;
        leftZ -= n;
        SkASSERT(leftZ >= 0);
    }
 
    if (riteZ) {
        // walk row to the end, and then we'll back up to trim riteZ
        while (width > 0) {
            int n = row[0];
            SkASSERT(n <= width);
            width -= n;
            row += 2;
        }
        // now skip whole runs of zeros
        do {
            row -= 2;
            SkASSERT(0 == row[1]);
            int n = row[0];
            SkASSERT(n > 0);
            if (n > riteZ) {
                row[0] = n - riteZ;
                break;
            }
            riteZ -= n;
            SkASSERT(riteZ >= 0);
        } while (riteZ > 0);
    }
 
    return trim;
}

upscaleBW2A8()

static void upscaleBW2A8 ( SkMask *  dstMask, const SkMask &  srcMask  )

static

Definition at line 1868 of file SkAAClip.cpp.

                                                                 {
    SkASSERT(SkMask::kBW_Format == srcMask.fFormat);
    SkASSERT(SkMask::kA8_Format == dstMask->fFormat);
 
    const int width = srcMask.fBounds.width();
    const int height = srcMask.fBounds.height();
 
    const uint8_t* SK_RESTRICT src = (const uint8_t*)srcMask.fImage;
    const size_t srcRB = srcMask.fRowBytes;
    uint8_t* SK_RESTRICT dst = const_cast<uint8_t*>(dstMask->fImage);
    const size_t dstRB = dstMask->fRowBytes;
 
    const int wholeBytes = width >> 3;
    const int leftOverBits = width & 7;
 
    for (int y = 0; y < height; ++y) {
        uint8_t* SK_RESTRICT d = dst;
        for (int i = 0; i < wholeBytes; ++i) {
            int srcByte = src[i];
            d[0] = bit2byte(srcByte & (1 << 7));
            d[1] = bit2byte(srcByte & (1 << 6));
            d[2] = bit2byte(srcByte & (1 << 5));
            d[3] = bit2byte(srcByte & (1 << 4));
            d[4] = bit2byte(srcByte & (1 << 3));
            d[5] = bit2byte(srcByte & (1 << 2));
            d[6] = bit2byte(srcByte & (1 << 1));
            d[7] = bit2byte(srcByte & (1 << 0));
            d += 8;
        }
        if (leftOverBits) {
            int srcByte = src[wholeBytes];
            for (int x = 0; x < leftOverBits; ++x) {
                *d++ = bit2byte(srcByte & 0x80);
                srcByte <<= 1;
            }
        }
        src += srcRB;
        dst += dstRB;
    }
}