12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162 |
- /*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "src/core/SkAAClip.h"
- #include "include/core/SkPath.h"
- #include "include/private/SkColorData.h"
- #include "include/private/SkMacros.h"
- #include "include/private/SkTo.h"
- #include "src/core/SkBlitter.h"
- #include "src/core/SkRectPriv.h"
- #include "src/core/SkScan.h"
- #include "src/utils/SkUTF.h"
- #include <atomic>
- #include <utility>
- class AutoAAClipValidate {
- public:
- AutoAAClipValidate(const SkAAClip& clip) : fClip(clip) {
- fClip.validate();
- }
- ~AutoAAClipValidate() {
- fClip.validate();
- }
- private:
- const SkAAClip& fClip;
- };
- #ifdef SK_DEBUG
- #define AUTO_AACLIP_VALIDATE(clip) AutoAAClipValidate acv(clip)
- #else
- #define AUTO_AACLIP_VALIDATE(clip)
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- #define kMaxInt32 0x7FFFFFFF
- #ifdef SK_DEBUG
- static inline bool x_in_rect(int x, const SkIRect& rect) {
- return (unsigned)(x - rect.fLeft) < (unsigned)rect.width();
- }
- #endif
- static inline bool y_in_rect(int y, const SkIRect& rect) {
- return (unsigned)(y - rect.fTop) < (unsigned)rect.height();
- }
- /*
- * Data runs are packed [count, alpha]
- */
- struct SkAAClip::YOffset {
- int32_t fY;
- uint32_t fOffset;
- };
- struct SkAAClip::RunHead {
- std::atomic<int32_t> fRefCnt;
- int32_t fRowCount;
- size_t fDataSize;
- YOffset* yoffsets() {
- return (YOffset*)((char*)this + sizeof(RunHead));
- }
- const YOffset* yoffsets() const {
- return (const YOffset*)((const char*)this + sizeof(RunHead));
- }
- uint8_t* data() {
- return (uint8_t*)(this->yoffsets() + fRowCount);
- }
- const uint8_t* data() const {
- return (const uint8_t*)(this->yoffsets() + fRowCount);
- }
- static RunHead* Alloc(int rowCount, size_t dataSize) {
- size_t size = sizeof(RunHead) + rowCount * sizeof(YOffset) + dataSize;
- RunHead* head = (RunHead*)sk_malloc_throw(size);
- head->fRefCnt.store(1);
- head->fRowCount = rowCount;
- head->fDataSize = dataSize;
- return head;
- }
- static int ComputeRowSizeForWidth(int width) {
- // 2 bytes per segment, where each segment can store up to 255 for count
- int segments = 0;
- while (width > 0) {
- segments += 1;
- int n = SkMin32(width, 255);
- width -= n;
- }
- return segments * 2; // each segment is row[0] + row[1] (n + alpha)
- }
- static RunHead* AllocRect(const SkIRect& bounds) {
- SkASSERT(!bounds.isEmpty());
- int width = bounds.width();
- size_t rowSize = ComputeRowSizeForWidth(width);
- RunHead* head = RunHead::Alloc(1, rowSize);
- YOffset* yoff = head->yoffsets();
- yoff->fY = bounds.height() - 1;
- yoff->fOffset = 0;
- uint8_t* row = head->data();
- while (width > 0) {
- int n = SkMin32(width, 255);
- row[0] = n;
- row[1] = 0xFF;
- width -= n;
- row += 2;
- }
- return head;
- }
- };
- class SkAAClip::Iter {
- public:
- Iter(const SkAAClip&);
- bool done() const { return fDone; }
- int top() const { return fTop; }
- int bottom() const { return fBottom; }
- const uint8_t* data() const { return fData; }
- void next();
- private:
- const YOffset* fCurrYOff;
- const YOffset* fStopYOff;
- const uint8_t* fData;
- int fTop, fBottom;
- bool fDone;
- };
- SkAAClip::Iter::Iter(const SkAAClip& clip) {
- if (clip.isEmpty()) {
- fDone = true;
- fTop = fBottom = clip.fBounds.fBottom;
- fData = nullptr;
- fCurrYOff = nullptr;
- fStopYOff = nullptr;
- return;
- }
- const RunHead* head = clip.fRunHead;
- fCurrYOff = head->yoffsets();
- fStopYOff = fCurrYOff + head->fRowCount;
- fData = head->data() + fCurrYOff->fOffset;
- // setup first value
- fTop = clip.fBounds.fTop;
- fBottom = clip.fBounds.fTop + fCurrYOff->fY + 1;
- fDone = false;
- }
- void SkAAClip::Iter::next() {
- if (!fDone) {
- const YOffset* prev = fCurrYOff;
- const YOffset* curr = prev + 1;
- SkASSERT(curr <= fStopYOff);
- fTop = fBottom;
- if (curr >= fStopYOff) {
- fDone = true;
- fBottom = kMaxInt32;
- fData = nullptr;
- } else {
- fBottom += curr->fY - prev->fY;
- fData += curr->fOffset - prev->fOffset;
- fCurrYOff = curr;
- }
- }
- }
- #ifdef SK_DEBUG
- // assert we're exactly width-wide, and then return the number of bytes used
- static size_t compute_row_length(const uint8_t row[], int width) {
- const uint8_t* origRow = row;
- while (width > 0) {
- int n = row[0];
- SkASSERT(n > 0);
- SkASSERT(n <= width);
- row += 2;
- width -= n;
- }
- SkASSERT(0 == width);
- return row - origRow;
- }
- void SkAAClip::validate() const {
- if (nullptr == fRunHead) {
- SkASSERT(fBounds.isEmpty());
- return;
- }
- SkASSERT(!fBounds.isEmpty());
- const RunHead* head = fRunHead;
- SkASSERT(head->fRefCnt.load() > 0);
- SkASSERT(head->fRowCount > 0);
- const YOffset* yoff = head->yoffsets();
- const YOffset* ystop = yoff + head->fRowCount;
- const int lastY = fBounds.height() - 1;
- // Y and offset must be monotonic
- int prevY = -1;
- int32_t prevOffset = -1;
- while (yoff < ystop) {
- SkASSERT(prevY < yoff->fY);
- SkASSERT(yoff->fY <= lastY);
- prevY = yoff->fY;
- SkASSERT(prevOffset < (int32_t)yoff->fOffset);
- prevOffset = yoff->fOffset;
- const uint8_t* row = head->data() + yoff->fOffset;
- size_t rowLength = compute_row_length(row, fBounds.width());
- SkASSERT(yoff->fOffset + rowLength <= head->fDataSize);
- yoff += 1;
- }
- // check the last entry;
- --yoff;
- SkASSERT(yoff->fY == lastY);
- }
- static void dump_one_row(const uint8_t* SK_RESTRICT row,
- int width, int leading_num) {
- if (leading_num) {
- SkDebugf( "%03d ", leading_num );
- }
- while (width > 0) {
- int n = row[0];
- int val = row[1];
- char out = '.';
- if (val == 0xff) {
- out = '*';
- } else if (val > 0) {
- out = '+';
- }
- for (int i = 0 ; i < n ; i++) {
- SkDebugf( "%c", out );
- }
- row += 2;
- width -= n;
- }
- SkDebugf( "\n" );
- }
- void SkAAClip::debug(bool compress_y) const {
- Iter iter(*this);
- const int width = fBounds.width();
- int y = fBounds.fTop;
- while (!iter.done()) {
- if (compress_y) {
- dump_one_row(iter.data(), width, iter.bottom() - iter.top() + 1);
- } else {
- do {
- dump_one_row(iter.data(), width, 0);
- } while (++y < iter.bottom());
- }
- iter.next();
- }
- }
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- // Count the number of zeros on the left and right edges of the passed in
- // RLE row. If 'row' is all zeros return 'width' in both variables.
- static void count_left_right_zeros(const uint8_t* row, int width,
- int* leftZ, int* riteZ) {
- 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;
- }
- // modify row in place, trimming off (zeros) from the left and right sides.
- // return the number of bytes that were completely eliminated from the left
- static int trim_row_left_right(uint8_t* row, int width, int leftZ, int riteZ) {
- 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;
- }
- bool SkAAClip::trimLeftRight() {
- if (this->isEmpty()) {
- return false;
- }
- AUTO_AACLIP_VALIDATE(*this);
- const int width = fBounds.width();
- RunHead* head = fRunHead;
- YOffset* yoff = head->yoffsets();
- YOffset* stop = yoff + head->fRowCount;
- uint8_t* base = head->data();
- // After this loop, 'leftZeros' & 'rightZeros' will contain the minimum
- // number of zeros on the left and right of the clip. This information
- // can be used to shrink the bounding box.
- int leftZeros = width;
- int riteZeros = width;
- while (yoff < stop) {
- int L, R;
- count_left_right_zeros(base + yoff->fOffset, width, &L, &R);
- SkASSERT(L + R < width || (L == width && R == width));
- if (L < leftZeros) {
- leftZeros = L;
- }
- if (R < riteZeros) {
- riteZeros = R;
- }
- if (0 == (leftZeros | riteZeros)) {
- // no trimming to do
- return true;
- }
- yoff += 1;
- }
- SkASSERT(leftZeros || riteZeros);
- if (width == leftZeros) {
- SkASSERT(width == riteZeros);
- return this->setEmpty();
- }
- this->validate();
- fBounds.fLeft += leftZeros;
- fBounds.fRight -= riteZeros;
- SkASSERT(!fBounds.isEmpty());
- // For now we don't realloc the storage (for time), we just shrink in place
- // This means we don't have to do any memmoves either, since we can just
- // play tricks with the yoff->fOffset for each row
- yoff = head->yoffsets();
- while (yoff < stop) {
- uint8_t* row = base + yoff->fOffset;
- SkDEBUGCODE((void)compute_row_length(row, width);)
- yoff->fOffset += trim_row_left_right(row, width, leftZeros, riteZeros);
- SkDEBUGCODE((void)compute_row_length(base + yoff->fOffset, width - leftZeros - riteZeros);)
- yoff += 1;
- }
- return true;
- }
- static bool row_is_all_zeros(const uint8_t* row, int width) {
- 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;
- }
- bool SkAAClip::trimTopBottom() {
- if (this->isEmpty()) {
- return false;
- }
- this->validate();
- const int width = fBounds.width();
- RunHead* head = fRunHead;
- YOffset* yoff = head->yoffsets();
- YOffset* stop = yoff + head->fRowCount;
- const uint8_t* base = head->data();
- // Look to trim away empty rows from the top.
- //
- int skip = 0;
- while (yoff < stop) {
- const uint8_t* data = base + yoff->fOffset;
- if (!row_is_all_zeros(data, width)) {
- break;
- }
- skip += 1;
- yoff += 1;
- }
- SkASSERT(skip <= head->fRowCount);
- if (skip == head->fRowCount) {
- return this->setEmpty();
- }
- if (skip > 0) {
- // adjust fRowCount and fBounds.fTop, and slide all the data up
- // as we remove [skip] number of YOffset entries
- yoff = head->yoffsets();
- int dy = yoff[skip - 1].fY + 1;
- for (int i = skip; i < head->fRowCount; ++i) {
- SkASSERT(yoff[i].fY >= dy);
- yoff[i].fY -= dy;
- }
- YOffset* dst = head->yoffsets();
- size_t size = head->fRowCount * sizeof(YOffset) + head->fDataSize;
- memmove(dst, dst + skip, size - skip * sizeof(YOffset));
- fBounds.fTop += dy;
- SkASSERT(!fBounds.isEmpty());
- head->fRowCount -= skip;
- SkASSERT(head->fRowCount > 0);
- this->validate();
- // need to reset this after the memmove
- base = head->data();
- }
- // Look to trim away empty rows from the bottom.
- // We know that we have at least one non-zero row, so we can just walk
- // backwards without checking for running past the start.
- //
- stop = yoff = head->yoffsets() + head->fRowCount;
- do {
- yoff -= 1;
- } while (row_is_all_zeros(base + yoff->fOffset, width));
- skip = SkToInt(stop - yoff - 1);
- SkASSERT(skip >= 0 && skip < head->fRowCount);
- if (skip > 0) {
- // removing from the bottom is easier than from the top, as we don't
- // have to adjust any of the Y values, we just have to trim the array
- memmove(stop - skip, stop, head->fDataSize);
- fBounds.fBottom = fBounds.fTop + yoff->fY + 1;
- SkASSERT(!fBounds.isEmpty());
- head->fRowCount -= skip;
- SkASSERT(head->fRowCount > 0);
- }
- this->validate();
- return true;
- }
- // can't validate before we're done, since trimming is part of the process of
- // making us valid after the Builder. Since we build from top to bottom, its
- // possible our fBounds.fBottom is bigger than our last scanline of data, so
- // we trim fBounds.fBottom back up.
- //
- // TODO: check for duplicates in X and Y to further compress our data
- //
- bool SkAAClip::trimBounds() {
- if (this->isEmpty()) {
- return false;
- }
- const RunHead* head = fRunHead;
- const YOffset* yoff = head->yoffsets();
- SkASSERT(head->fRowCount > 0);
- const YOffset& lastY = yoff[head->fRowCount - 1];
- SkASSERT(lastY.fY + 1 <= fBounds.height());
- fBounds.fBottom = fBounds.fTop + lastY.fY + 1;
- SkASSERT(lastY.fY + 1 == fBounds.height());
- SkASSERT(!fBounds.isEmpty());
- return this->trimTopBottom() && this->trimLeftRight();
- }
- ///////////////////////////////////////////////////////////////////////////////
- void SkAAClip::freeRuns() {
- if (fRunHead) {
- SkASSERT(fRunHead->fRefCnt.load() >= 1);
- if (1 == fRunHead->fRefCnt--) {
- sk_free(fRunHead);
- }
- }
- }
- SkAAClip::SkAAClip() {
- fBounds.setEmpty();
- fRunHead = nullptr;
- }
- SkAAClip::SkAAClip(const SkAAClip& src) {
- SkDEBUGCODE(fBounds.setEmpty();) // need this for validate
- fRunHead = nullptr;
- *this = src;
- }
- SkAAClip::~SkAAClip() {
- this->freeRuns();
- }
- SkAAClip& SkAAClip::operator=(const SkAAClip& src) {
- AUTO_AACLIP_VALIDATE(*this);
- src.validate();
- if (this != &src) {
- this->freeRuns();
- fBounds = src.fBounds;
- fRunHead = src.fRunHead;
- if (fRunHead) {
- fRunHead->fRefCnt++;
- }
- }
- return *this;
- }
- bool operator==(const SkAAClip& a, const SkAAClip& b) {
- a.validate();
- b.validate();
- if (&a == &b) {
- return true;
- }
- if (a.fBounds != b.fBounds) {
- return false;
- }
- const SkAAClip::RunHead* ah = a.fRunHead;
- const SkAAClip::RunHead* bh = b.fRunHead;
- // this catches empties and rects being equal
- if (ah == bh) {
- return true;
- }
- // now we insist that both are complex (but different ptrs)
- if (!a.fRunHead || !b.fRunHead) {
- return false;
- }
- return ah->fRowCount == bh->fRowCount &&
- ah->fDataSize == bh->fDataSize &&
- !memcmp(ah->data(), bh->data(), ah->fDataSize);
- }
- void SkAAClip::swap(SkAAClip& other) {
- AUTO_AACLIP_VALIDATE(*this);
- other.validate();
- using std::swap;
- swap(fBounds, other.fBounds);
- swap(fRunHead, other.fRunHead);
- }
- bool SkAAClip::set(const SkAAClip& src) {
- *this = src;
- return !this->isEmpty();
- }
- bool SkAAClip::setEmpty() {
- this->freeRuns();
- fBounds.setEmpty();
- fRunHead = nullptr;
- return false;
- }
- bool SkAAClip::setRect(const SkIRect& bounds) {
- if (bounds.isEmpty()) {
- return this->setEmpty();
- }
- AUTO_AACLIP_VALIDATE(*this);
- #if 0
- SkRect r;
- r.set(bounds);
- SkPath path;
- path.addRect(r);
- return this->setPath(path);
- #else
- this->freeRuns();
- fBounds = bounds;
- fRunHead = RunHead::AllocRect(bounds);
- SkASSERT(!this->isEmpty());
- return true;
- #endif
- }
- bool SkAAClip::isRect() const {
- if (this->isEmpty()) {
- return false;
- }
- const RunHead* head = fRunHead;
- if (head->fRowCount != 1) {
- return false;
- }
- const YOffset* yoff = head->yoffsets();
- if (yoff->fY != fBounds.fBottom - 1) {
- return false;
- }
- const uint8_t* row = head->data() + yoff->fOffset;
- int width = fBounds.width();
- do {
- if (row[1] != 0xFF) {
- return false;
- }
- int n = row[0];
- SkASSERT(n <= width);
- width -= n;
- row += 2;
- } while (width > 0);
- return true;
- }
- bool SkAAClip::setRect(const SkRect& r, bool doAA) {
- if (r.isEmpty()) {
- return this->setEmpty();
- }
- AUTO_AACLIP_VALIDATE(*this);
- // TODO: special case this
- SkPath path;
- path.addRect(r);
- return this->setPath(path, nullptr, doAA);
- }
- static void append_run(SkTDArray<uint8_t>& array, uint8_t value, int count) {
- SkASSERT(count >= 0);
- while (count > 0) {
- int n = count;
- if (n > 255) {
- n = 255;
- }
- uint8_t* data = array.append(2);
- data[0] = n;
- data[1] = value;
- count -= n;
- }
- }
- bool SkAAClip::setRegion(const SkRegion& rgn) {
- if (rgn.isEmpty()) {
- return this->setEmpty();
- }
- if (rgn.isRect()) {
- return this->setRect(rgn.getBounds());
- }
- #if 0
- SkAAClip clip;
- SkRegion::Iterator iter(rgn);
- for (; !iter.done(); iter.next()) {
- clip.op(iter.rect(), SkRegion::kUnion_Op);
- }
- this->swap(clip);
- return !this->isEmpty();
- #else
- const SkIRect& bounds = rgn.getBounds();
- const int offsetX = bounds.fLeft;
- const int offsetY = bounds.fTop;
- SkTDArray<YOffset> yArray;
- SkTDArray<uint8_t> xArray;
- yArray.setReserve(SkMin32(bounds.height(), 1024));
- xArray.setReserve(SkMin32(bounds.width(), 512) * 128);
- SkRegion::Iterator iter(rgn);
- int prevRight = 0;
- int prevBot = 0;
- YOffset* currY = nullptr;
- for (; !iter.done(); iter.next()) {
- const SkIRect& r = iter.rect();
- SkASSERT(bounds.contains(r));
- int bot = r.fBottom - offsetY;
- SkASSERT(bot >= prevBot);
- if (bot > prevBot) {
- if (currY) {
- // flush current row
- append_run(xArray, 0, bounds.width() - prevRight);
- }
- // did we introduce an empty-gap from the prev row?
- int top = r.fTop - offsetY;
- if (top > prevBot) {
- currY = yArray.append();
- currY->fY = top - 1;
- currY->fOffset = xArray.count();
- append_run(xArray, 0, bounds.width());
- }
- // create a new record for this Y value
- currY = yArray.append();
- currY->fY = bot - 1;
- currY->fOffset = xArray.count();
- prevRight = 0;
- prevBot = bot;
- }
- int x = r.fLeft - offsetX;
- append_run(xArray, 0, x - prevRight);
- int w = r.fRight - r.fLeft;
- append_run(xArray, 0xFF, w);
- prevRight = x + w;
- SkASSERT(prevRight <= bounds.width());
- }
- // flush last row
- append_run(xArray, 0, bounds.width() - prevRight);
- // now pack everything into a RunHead
- RunHead* head = RunHead::Alloc(yArray.count(), xArray.bytes());
- memcpy(head->yoffsets(), yArray.begin(), yArray.bytes());
- memcpy(head->data(), xArray.begin(), xArray.bytes());
- this->setEmpty();
- fBounds = bounds;
- fRunHead = head;
- this->validate();
- return true;
- #endif
- }
- ///////////////////////////////////////////////////////////////////////////////
- const uint8_t* SkAAClip::findRow(int y, int* lastYForRow) const {
- SkASSERT(fRunHead);
- if (!y_in_rect(y, fBounds)) {
- return nullptr;
- }
- y -= fBounds.y(); // our yoffs values are relative to the top
- const YOffset* yoff = fRunHead->yoffsets();
- while (yoff->fY < y) {
- yoff += 1;
- SkASSERT(yoff - fRunHead->yoffsets() < fRunHead->fRowCount);
- }
- if (lastYForRow) {
- *lastYForRow = fBounds.y() + yoff->fY;
- }
- return fRunHead->data() + yoff->fOffset;
- }
- const uint8_t* SkAAClip::findX(const uint8_t data[], int x, int* initialCount) const {
- SkASSERT(x_in_rect(x, fBounds));
- x -= fBounds.x();
- // first skip up to X
- for (;;) {
- int n = data[0];
- if (x < n) {
- if (initialCount) {
- *initialCount = n - x;
- }
- break;
- }
- data += 2;
- x -= n;
- }
- return data;
- }
- bool SkAAClip::quickContains(int left, int top, int right, int bottom) const {
- if (this->isEmpty()) {
- return false;
- }
- if (!fBounds.contains(left, top, right, bottom)) {
- return false;
- }
- #if 0
- if (this->isRect()) {
- return true;
- }
- #endif
- int lastY SK_INIT_TO_AVOID_WARNING;
- const uint8_t* row = this->findRow(top, &lastY);
- if (lastY < bottom) {
- return false;
- }
- // now just need to check in X
- int count;
- row = this->findX(row, left, &count);
- #if 0
- return count >= (right - left) && 0xFF == row[1];
- #else
- int rectWidth = right - left;
- while (0xFF == row[1]) {
- if (count >= rectWidth) {
- return true;
- }
- rectWidth -= count;
- row += 2;
- count = row[0];
- }
- return false;
- #endif
- }
- ///////////////////////////////////////////////////////////////////////////////
- class SkAAClip::Builder {
- SkIRect fBounds;
- struct Row {
- int fY;
- int fWidth;
- SkTDArray<uint8_t>* fData;
- };
- SkTDArray<Row> fRows;
- Row* fCurrRow;
- int fPrevY;
- int fWidth;
- int fMinY;
- public:
- Builder(const SkIRect& bounds) : fBounds(bounds) {
- fPrevY = -1;
- fWidth = bounds.width();
- fCurrRow = nullptr;
- fMinY = bounds.fTop;
- }
- ~Builder() {
- Row* row = fRows.begin();
- Row* stop = fRows.end();
- while (row < stop) {
- delete row->fData;
- row += 1;
- }
- }
- const SkIRect& getBounds() const { return fBounds; }
- void addRun(int x, int y, U8CPU alpha, int count) {
- SkASSERT(count > 0);
- SkASSERT(fBounds.contains(x, y));
- SkASSERT(fBounds.contains(x + count - 1, y));
- x -= fBounds.left();
- y -= fBounds.top();
- Row* row = fCurrRow;
- if (y != fPrevY) {
- SkASSERT(y > fPrevY);
- fPrevY = y;
- row = this->flushRow(true);
- row->fY = y;
- row->fWidth = 0;
- SkASSERT(row->fData);
- SkASSERT(0 == row->fData->count());
- fCurrRow = row;
- }
- SkASSERT(row->fWidth <= x);
- SkASSERT(row->fWidth < fBounds.width());
- SkTDArray<uint8_t>& data = *row->fData;
- int gap = x - row->fWidth;
- if (gap) {
- AppendRun(data, 0, gap);
- row->fWidth += gap;
- SkASSERT(row->fWidth < fBounds.width());
- }
- AppendRun(data, alpha, count);
- row->fWidth += count;
- SkASSERT(row->fWidth <= fBounds.width());
- }
- void addColumn(int x, int y, U8CPU alpha, int height) {
- SkASSERT(fBounds.contains(x, y + height - 1));
- this->addRun(x, y, alpha, 1);
- this->flushRowH(fCurrRow);
- y -= fBounds.fTop;
- SkASSERT(y == fCurrRow->fY);
- fCurrRow->fY = y + height - 1;
- }
- void addRectRun(int x, int y, int width, int height) {
- SkASSERT(fBounds.contains(x + width - 1, y + height - 1));
- this->addRun(x, y, 0xFF, width);
- // we assum the rect must be all we'll see for these scanlines
- // so we ensure our row goes all the way to our right
- this->flushRowH(fCurrRow);
- y -= fBounds.fTop;
- SkASSERT(y == fCurrRow->fY);
- fCurrRow->fY = y + height - 1;
- }
- void addAntiRectRun(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) {
- // According to SkBlitter.cpp, no matter whether leftAlpha is 0 or positive,
- // we should always consider [x, x+1] as the left-most column and [x+1, x+1+width]
- // as the rect with full alpha.
- SkASSERT(fBounds.contains(x + width + (rightAlpha > 0 ? 1 : 0),
- y + height - 1));
- SkASSERT(width >= 0);
- // Conceptually we're always adding 3 runs, but we should
- // merge or omit them if possible.
- if (leftAlpha == 0xFF) {
- width++;
- } else if (leftAlpha > 0) {
- this->addRun(x++, y, leftAlpha, 1);
- } else {
- // leftAlpha is 0, ignore the left column
- x++;
- }
- if (rightAlpha == 0xFF) {
- width++;
- }
- if (width > 0) {
- this->addRun(x, y, 0xFF, width);
- }
- if (rightAlpha > 0 && rightAlpha < 255) {
- this->addRun(x + width, y, rightAlpha, 1);
- }
- // if we never called addRun, we might not have a fCurrRow yet
- if (fCurrRow) {
- // we assume the rect must be all we'll see for these scanlines
- // so we ensure our row goes all the way to our right
- this->flushRowH(fCurrRow);
- y -= fBounds.fTop;
- SkASSERT(y == fCurrRow->fY);
- fCurrRow->fY = y + height - 1;
- }
- }
- bool finish(SkAAClip* target) {
- this->flushRow(false);
- const Row* row = fRows.begin();
- const Row* stop = fRows.end();
- size_t dataSize = 0;
- while (row < stop) {
- dataSize += row->fData->count();
- row += 1;
- }
- if (0 == dataSize) {
- return target->setEmpty();
- }
- SkASSERT(fMinY >= fBounds.fTop);
- SkASSERT(fMinY < fBounds.fBottom);
- int adjustY = fMinY - fBounds.fTop;
- fBounds.fTop = fMinY;
- RunHead* head = RunHead::Alloc(fRows.count(), dataSize);
- YOffset* yoffset = head->yoffsets();
- uint8_t* data = head->data();
- uint8_t* baseData = data;
- row = fRows.begin();
- SkDEBUGCODE(int prevY = row->fY - 1;)
- while (row < stop) {
- SkASSERT(prevY < row->fY); // must be monotonic
- SkDEBUGCODE(prevY = row->fY);
- yoffset->fY = row->fY - adjustY;
- yoffset->fOffset = SkToU32(data - baseData);
- yoffset += 1;
- size_t n = row->fData->count();
- memcpy(data, row->fData->begin(), n);
- #ifdef SK_DEBUG
- size_t bytesNeeded = compute_row_length(data, fBounds.width());
- SkASSERT(bytesNeeded == n);
- #endif
- data += n;
- row += 1;
- }
- target->freeRuns();
- target->fBounds = fBounds;
- target->fRunHead = head;
- return target->trimBounds();
- }
- void dump() {
- this->validate();
- int y;
- for (y = 0; y < fRows.count(); ++y) {
- const Row& row = fRows[y];
- SkDebugf("Y:%3d W:%3d", row.fY, row.fWidth);
- const SkTDArray<uint8_t>& data = *row.fData;
- int count = data.count();
- SkASSERT(!(count & 1));
- const uint8_t* ptr = data.begin();
- for (int x = 0; x < count; x += 2) {
- SkDebugf(" [%3d:%02X]", ptr[0], ptr[1]);
- ptr += 2;
- }
- SkDebugf("\n");
- }
- }
- void validate() {
- #ifdef SK_DEBUG
- int prevY = -1;
- for (int i = 0; i < fRows.count(); ++i) {
- const Row& row = fRows[i];
- SkASSERT(prevY < row.fY);
- SkASSERT(fWidth == row.fWidth);
- int count = row.fData->count();
- const uint8_t* ptr = row.fData->begin();
- SkASSERT(!(count & 1));
- int w = 0;
- for (int x = 0; x < count; x += 2) {
- int n = ptr[0];
- SkASSERT(n > 0);
- w += n;
- SkASSERT(w <= fWidth);
- ptr += 2;
- }
- SkASSERT(w == fWidth);
- prevY = row.fY;
- }
- #endif
- }
- // only called by BuilderBlitter
- void setMinY(int y) {
- fMinY = y;
- }
- private:
- void flushRowH(Row* row) {
- // flush current row if needed
- if (row->fWidth < fWidth) {
- AppendRun(*row->fData, 0, fWidth - row->fWidth);
- row->fWidth = fWidth;
- }
- }
- Row* flushRow(bool readyForAnother) {
- Row* next = nullptr;
- int count = fRows.count();
- if (count > 0) {
- this->flushRowH(&fRows[count - 1]);
- }
- if (count > 1) {
- // are our last two runs the same?
- Row* prev = &fRows[count - 2];
- Row* curr = &fRows[count - 1];
- SkASSERT(prev->fWidth == fWidth);
- SkASSERT(curr->fWidth == fWidth);
- if (*prev->fData == *curr->fData) {
- prev->fY = curr->fY;
- if (readyForAnother) {
- curr->fData->rewind();
- next = curr;
- } else {
- delete curr->fData;
- fRows.removeShuffle(count - 1);
- }
- } else {
- if (readyForAnother) {
- next = fRows.append();
- next->fData = new SkTDArray<uint8_t>;
- }
- }
- } else {
- if (readyForAnother) {
- next = fRows.append();
- next->fData = new SkTDArray<uint8_t>;
- }
- }
- return next;
- }
- static void AppendRun(SkTDArray<uint8_t>& data, U8CPU alpha, int count) {
- do {
- int n = count;
- if (n > 255) {
- n = 255;
- }
- uint8_t* ptr = data.append(2);
- ptr[0] = n;
- ptr[1] = alpha;
- count -= n;
- } while (count > 0);
- }
- };
- class SkAAClip::BuilderBlitter : public SkBlitter {
- int fLastY;
- /*
- If we see a gap of 1 or more empty scanlines while building in Y-order,
- we inject an explicit empty scanline (alpha==0)
- See AAClipTest.cpp : test_path_with_hole()
- */
- void checkForYGap(int y) {
- SkASSERT(y >= fLastY);
- if (fLastY > -SK_MaxS32) {
- int gap = y - fLastY;
- if (gap > 1) {
- fBuilder->addRun(fLeft, y - 1, 0, fRight - fLeft);
- }
- }
- fLastY = y;
- }
- public:
- BuilderBlitter(Builder* builder) {
- fBuilder = builder;
- fLeft = builder->getBounds().fLeft;
- fRight = builder->getBounds().fRight;
- fMinY = SK_MaxS32;
- fLastY = -SK_MaxS32; // sentinel
- }
- void finish() {
- if (fMinY < SK_MaxS32) {
- fBuilder->setMinY(fMinY);
- }
- }
- /**
- Must evaluate clips in scan-line order, so don't want to allow blitV(),
- but an AAClip can be clipped down to a single pixel wide, so we
- must support it (given AntiRect semantics: minimum width is 2).
- Instead we'll rely on the runtime asserts to guarantee Y monotonicity;
- any failure cases that misses may have minor artifacts.
- */
- void blitV(int x, int y, int height, SkAlpha alpha) override {
- if (height == 1) {
- // We're still in scan-line order if height is 1
- // This is useful for Analytic AA
- const SkAlpha alphas[2] = {alpha, 0};
- const int16_t runs[2] = {1, 0};
- this->blitAntiH(x, y, alphas, runs);
- } else {
- this->recordMinY(y);
- fBuilder->addColumn(x, y, alpha, height);
- fLastY = y + height - 1;
- }
- }
- void blitRect(int x, int y, int width, int height) override {
- this->recordMinY(y);
- this->checkForYGap(y);
- fBuilder->addRectRun(x, y, width, height);
- fLastY = y + height - 1;
- }
- virtual void blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) override {
- this->recordMinY(y);
- this->checkForYGap(y);
- fBuilder->addAntiRectRun(x, y, width, height, leftAlpha, rightAlpha);
- fLastY = y + height - 1;
- }
- void blitMask(const SkMask&, const SkIRect& clip) override
- { unexpected(); }
- const SkPixmap* justAnOpaqueColor(uint32_t*) override {
- return nullptr;
- }
- void blitH(int x, int y, int width) override {
- this->recordMinY(y);
- this->checkForYGap(y);
- fBuilder->addRun(x, y, 0xFF, width);
- }
- virtual void blitAntiH(int x, int y, const SkAlpha alpha[],
- const int16_t runs[]) override {
- this->recordMinY(y);
- this->checkForYGap(y);
- for (;;) {
- int count = *runs;
- if (count <= 0) {
- return;
- }
- // The supersampler's buffer can be the width of the device, so
- // we may have to trim the run to our bounds. Previously, we assert that
- // the extra spans are always alpha==0.
- // However, the analytic AA is too sensitive to precision errors
- // so it may have extra spans with very tiny alpha because after several
- // arithmatic operations, the edge may bleed the path boundary a little bit.
- // Therefore, instead of always asserting alpha==0, we assert alpha < 0x10.
- int localX = x;
- int localCount = count;
- if (x < fLeft) {
- SkASSERT(0x10 > *alpha);
- int gap = fLeft - x;
- SkASSERT(gap <= count);
- localX += gap;
- localCount -= gap;
- }
- int right = x + count;
- if (right > fRight) {
- SkASSERT(0x10 > *alpha);
- localCount -= right - fRight;
- SkASSERT(localCount >= 0);
- }
- if (localCount) {
- fBuilder->addRun(localX, y, *alpha, localCount);
- }
- // Next run
- runs += count;
- alpha += count;
- x += count;
- }
- }
- private:
- Builder* fBuilder;
- int fLeft; // cache of builder's bounds' left edge
- int fRight;
- int fMinY;
- /*
- * We track this, in case the scan converter skipped some number of
- * scanlines at the (relative to the bounds it was given). This allows
- * the builder, during its finish, to trip its bounds down to the "real"
- * top.
- */
- void recordMinY(int y) {
- if (y < fMinY) {
- fMinY = y;
- }
- }
- void unexpected() {
- SK_ABORT("---- did not expect to get called here");
- }
- };
- bool SkAAClip::setPath(const SkPath& path, const SkRegion* clip, bool doAA) {
- AUTO_AACLIP_VALIDATE(*this);
- if (clip && clip->isEmpty()) {
- return this->setEmpty();
- }
- SkIRect ibounds;
- path.getBounds().roundOut(&ibounds);
- SkRegion tmpClip;
- if (nullptr == clip) {
- tmpClip.setRect(ibounds);
- clip = &tmpClip;
- }
- // Since we assert that the BuilderBlitter will never blit outside the intersection
- // of clip and ibounds, we create this snugClip to be that intersection and send it
- // to the scan-converter.
- SkRegion snugClip(*clip);
- if (path.isInverseFillType()) {
- ibounds = clip->getBounds();
- } else {
- if (ibounds.isEmpty() || !ibounds.intersect(clip->getBounds())) {
- return this->setEmpty();
- }
- snugClip.op(ibounds, SkRegion::kIntersect_Op);
- }
- Builder builder(ibounds);
- BuilderBlitter blitter(&builder);
- if (doAA) {
- SkScan::AntiFillPath(path, snugClip, &blitter, true);
- } else {
- SkScan::FillPath(path, snugClip, &blitter);
- }
- blitter.finish();
- return builder.finish(this);
- }
- ///////////////////////////////////////////////////////////////////////////////
- typedef void (*RowProc)(SkAAClip::Builder&, int bottom,
- const uint8_t* rowA, const SkIRect& rectA,
- const uint8_t* rowB, const SkIRect& rectB);
- typedef U8CPU (*AlphaProc)(U8CPU alphaA, U8CPU alphaB);
- static U8CPU sectAlphaProc(U8CPU alphaA, U8CPU alphaB) {
- // Multiply
- return SkMulDiv255Round(alphaA, alphaB);
- }
- static U8CPU unionAlphaProc(U8CPU alphaA, U8CPU alphaB) {
- // SrcOver
- return alphaA + alphaB - SkMulDiv255Round(alphaA, alphaB);
- }
- static U8CPU diffAlphaProc(U8CPU alphaA, U8CPU alphaB) {
- // SrcOut
- return SkMulDiv255Round(alphaA, 0xFF - alphaB);
- }
- static U8CPU xorAlphaProc(U8CPU alphaA, U8CPU alphaB) {
- // XOR
- return alphaA + alphaB - 2 * SkMulDiv255Round(alphaA, alphaB);
- }
- static AlphaProc find_alpha_proc(SkRegion::Op op) {
- switch (op) {
- case SkRegion::kIntersect_Op:
- return sectAlphaProc;
- case SkRegion::kDifference_Op:
- return diffAlphaProc;
- case SkRegion::kUnion_Op:
- return unionAlphaProc;
- case SkRegion::kXOR_Op:
- return xorAlphaProc;
- default:
- SkDEBUGFAIL("unexpected region op");
- return sectAlphaProc;
- }
- }
- class RowIter {
- public:
- RowIter(const uint8_t* row, const SkIRect& bounds) {
- fRow = row;
- fLeft = bounds.fLeft;
- fBoundsRight = bounds.fRight;
- if (row) {
- fRight = bounds.fLeft + row[0];
- SkASSERT(fRight <= fBoundsRight);
- fAlpha = row[1];
- fDone = false;
- } else {
- fDone = true;
- fRight = kMaxInt32;
- fAlpha = 0;
- }
- }
- bool done() const { return fDone; }
- int left() const { return fLeft; }
- int right() const { return fRight; }
- U8CPU alpha() const { return fAlpha; }
- void next() {
- if (!fDone) {
- fLeft = fRight;
- if (fRight == fBoundsRight) {
- fDone = true;
- fRight = kMaxInt32;
- fAlpha = 0;
- } else {
- fRow += 2;
- fRight += fRow[0];
- fAlpha = fRow[1];
- SkASSERT(fRight <= fBoundsRight);
- }
- }
- }
- private:
- const uint8_t* fRow;
- int fLeft;
- int fRight;
- int fBoundsRight;
- bool fDone;
- uint8_t fAlpha;
- };
- static void adjust_row(RowIter& iter, int& leftA, int& riteA, int rite) {
- if (rite == riteA) {
- iter.next();
- leftA = iter.left();
- riteA = iter.right();
- }
- }
- #if 0 // UNUSED
- static bool intersect(int& min, int& max, int boundsMin, int boundsMax) {
- SkASSERT(min < max);
- SkASSERT(boundsMin < boundsMax);
- if (min >= boundsMax || max <= boundsMin) {
- return false;
- }
- if (min < boundsMin) {
- min = boundsMin;
- }
- if (max > boundsMax) {
- max = boundsMax;
- }
- return true;
- }
- #endif
- static void operatorX(SkAAClip::Builder& builder, int lastY,
- RowIter& iterA, RowIter& iterB,
- AlphaProc proc, const SkIRect& bounds) {
- int leftA = iterA.left();
- int riteA = iterA.right();
- int leftB = iterB.left();
- int riteB = iterB.right();
- int prevRite = bounds.fLeft;
- do {
- U8CPU alphaA = 0;
- U8CPU alphaB = 0;
- int left, rite;
- if (leftA < leftB) {
- left = leftA;
- alphaA = iterA.alpha();
- if (riteA <= leftB) {
- rite = riteA;
- } else {
- rite = leftA = leftB;
- }
- } else if (leftB < leftA) {
- left = leftB;
- alphaB = iterB.alpha();
- if (riteB <= leftA) {
- rite = riteB;
- } else {
- rite = leftB = leftA;
- }
- } else {
- left = leftA; // or leftB, since leftA == leftB
- rite = leftA = leftB = SkMin32(riteA, riteB);
- alphaA = iterA.alpha();
- alphaB = iterB.alpha();
- }
- if (left >= bounds.fRight) {
- break;
- }
- if (rite > bounds.fRight) {
- rite = bounds.fRight;
- }
- if (left >= bounds.fLeft) {
- SkASSERT(rite > left);
- builder.addRun(left, lastY, proc(alphaA, alphaB), rite - left);
- prevRite = rite;
- }
- adjust_row(iterA, leftA, riteA, rite);
- adjust_row(iterB, leftB, riteB, rite);
- } while (!iterA.done() || !iterB.done());
- if (prevRite < bounds.fRight) {
- builder.addRun(prevRite, lastY, 0, bounds.fRight - prevRite);
- }
- }
- static void adjust_iter(SkAAClip::Iter& iter, int& topA, int& botA, int bot) {
- if (bot == botA) {
- iter.next();
- topA = botA;
- SkASSERT(botA == iter.top());
- botA = iter.bottom();
- }
- }
- static void operateY(SkAAClip::Builder& builder, const SkAAClip& A,
- const SkAAClip& B, SkRegion::Op op) {
- AlphaProc proc = find_alpha_proc(op);
- const SkIRect& bounds = builder.getBounds();
- SkAAClip::Iter iterA(A);
- SkAAClip::Iter iterB(B);
- SkASSERT(!iterA.done());
- int topA = iterA.top();
- int botA = iterA.bottom();
- SkASSERT(!iterB.done());
- int topB = iterB.top();
- int botB = iterB.bottom();
- do {
- const uint8_t* rowA = nullptr;
- const uint8_t* rowB = nullptr;
- int top, bot;
- if (topA < topB) {
- top = topA;
- rowA = iterA.data();
- if (botA <= topB) {
- bot = botA;
- } else {
- bot = topA = topB;
- }
- } else if (topB < topA) {
- top = topB;
- rowB = iterB.data();
- if (botB <= topA) {
- bot = botB;
- } else {
- bot = topB = topA;
- }
- } else {
- top = topA; // or topB, since topA == topB
- bot = topA = topB = SkMin32(botA, botB);
- rowA = iterA.data();
- rowB = iterB.data();
- }
- if (top >= bounds.fBottom) {
- break;
- }
- if (bot > bounds.fBottom) {
- bot = bounds.fBottom;
- }
- SkASSERT(top < bot);
- if (!rowA && !rowB) {
- builder.addRun(bounds.fLeft, bot - 1, 0, bounds.width());
- } else if (top >= bounds.fTop) {
- SkASSERT(bot <= bounds.fBottom);
- RowIter rowIterA(rowA, rowA ? A.getBounds() : bounds);
- RowIter rowIterB(rowB, rowB ? B.getBounds() : bounds);
- operatorX(builder, bot - 1, rowIterA, rowIterB, proc, bounds);
- }
- adjust_iter(iterA, topA, botA, bot);
- adjust_iter(iterB, topB, botB, bot);
- } while (!iterA.done() || !iterB.done());
- }
- bool SkAAClip::op(const SkAAClip& clipAOrig, const SkAAClip& clipBOrig,
- SkRegion::Op op) {
- AUTO_AACLIP_VALIDATE(*this);
- if (SkRegion::kReplace_Op == op) {
- return this->set(clipBOrig);
- }
- const SkAAClip* clipA = &clipAOrig;
- const SkAAClip* clipB = &clipBOrig;
- if (SkRegion::kReverseDifference_Op == op) {
- using std::swap;
- swap(clipA, clipB);
- op = SkRegion::kDifference_Op;
- }
- bool a_empty = clipA->isEmpty();
- bool b_empty = clipB->isEmpty();
- SkIRect bounds;
- switch (op) {
- case SkRegion::kDifference_Op:
- if (a_empty) {
- return this->setEmpty();
- }
- if (b_empty || !SkIRect::Intersects(clipA->fBounds, clipB->fBounds)) {
- return this->set(*clipA);
- }
- bounds = clipA->fBounds;
- break;
- case SkRegion::kIntersect_Op:
- if ((a_empty | b_empty) || !bounds.intersect(clipA->fBounds,
- clipB->fBounds)) {
- return this->setEmpty();
- }
- break;
- case SkRegion::kUnion_Op:
- case SkRegion::kXOR_Op:
- if (a_empty) {
- return this->set(*clipB);
- }
- if (b_empty) {
- return this->set(*clipA);
- }
- bounds = clipA->fBounds;
- bounds.join(clipB->fBounds);
- break;
- default:
- SkDEBUGFAIL("unknown region op");
- return !this->isEmpty();
- }
- SkASSERT(SkIRect::Intersects(bounds, clipB->fBounds));
- SkASSERT(SkIRect::Intersects(bounds, clipB->fBounds));
- Builder builder(bounds);
- operateY(builder, *clipA, *clipB, op);
- return builder.finish(this);
- }
- /*
- * It can be expensive to build a local aaclip before applying the op, so
- * we first see if we can restrict the bounds of new rect to our current
- * bounds, or note that the new rect subsumes our current clip.
- */
- bool SkAAClip::op(const SkIRect& rOrig, SkRegion::Op op) {
- SkIRect rStorage;
- const SkIRect* r = &rOrig;
- switch (op) {
- case SkRegion::kIntersect_Op:
- if (!rStorage.intersect(rOrig, fBounds)) {
- // no overlap, so we're empty
- return this->setEmpty();
- }
- if (rStorage == fBounds) {
- // we were wholly inside the rect, no change
- return !this->isEmpty();
- }
- if (this->quickContains(rStorage)) {
- // the intersection is wholly inside us, we're a rect
- return this->setRect(rStorage);
- }
- r = &rStorage; // use the intersected bounds
- break;
- case SkRegion::kDifference_Op:
- break;
- case SkRegion::kUnion_Op:
- if (rOrig.contains(fBounds)) {
- return this->setRect(rOrig);
- }
- break;
- default:
- break;
- }
- SkAAClip clip;
- clip.setRect(*r);
- return this->op(*this, clip, op);
- }
- bool SkAAClip::op(const SkRect& rOrig, SkRegion::Op op, bool doAA) {
- SkRect rStorage, boundsStorage;
- const SkRect* r = &rOrig;
- boundsStorage.set(fBounds);
- switch (op) {
- case SkRegion::kIntersect_Op:
- case SkRegion::kDifference_Op:
- if (!rStorage.intersect(rOrig, boundsStorage)) {
- if (SkRegion::kIntersect_Op == op) {
- return this->setEmpty();
- } else { // kDifference
- return !this->isEmpty();
- }
- }
- r = &rStorage; // use the intersected bounds
- break;
- case SkRegion::kUnion_Op:
- if (rOrig.contains(boundsStorage)) {
- return this->setRect(rOrig);
- }
- break;
- default:
- break;
- }
- SkAAClip clip;
- clip.setRect(*r, doAA);
- return this->op(*this, clip, op);
- }
- bool SkAAClip::op(const SkAAClip& clip, SkRegion::Op op) {
- return this->op(*this, clip, op);
- }
- ///////////////////////////////////////////////////////////////////////////////
- bool SkAAClip::translate(int dx, int dy, SkAAClip* dst) const {
- if (nullptr == dst) {
- return !this->isEmpty();
- }
- if (this->isEmpty()) {
- return dst->setEmpty();
- }
- if (this != dst) {
- fRunHead->fRefCnt++;
- dst->freeRuns();
- dst->fRunHead = fRunHead;
- dst->fBounds = fBounds;
- }
- dst->fBounds.offset(dx, dy);
- return true;
- }
- static void expand_row_to_mask(uint8_t* SK_RESTRICT mask,
- const uint8_t* SK_RESTRICT row,
- int width) {
- while (width > 0) {
- int n = row[0];
- SkASSERT(width >= n);
- memset(mask, row[1], n);
- mask += n;
- row += 2;
- width -= n;
- }
- SkASSERT(0 == width);
- }
- void SkAAClip::copyToMask(SkMask* mask) const {
- mask->fFormat = SkMask::kA8_Format;
- if (this->isEmpty()) {
- mask->fBounds.setEmpty();
- mask->fImage = nullptr;
- mask->fRowBytes = 0;
- return;
- }
- mask->fBounds = fBounds;
- mask->fRowBytes = fBounds.width();
- size_t size = mask->computeImageSize();
- mask->fImage = SkMask::AllocImage(size);
- Iter iter(*this);
- uint8_t* dst = mask->fImage;
- const int width = fBounds.width();
- int y = fBounds.fTop;
- while (!iter.done()) {
- do {
- expand_row_to_mask(dst, iter.data(), width);
- dst += mask->fRowBytes;
- } while (++y < iter.bottom());
- iter.next();
- }
- }
- ///////////////////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////////////////////////////////
- static void expandToRuns(const uint8_t* SK_RESTRICT data, int initialCount, int width,
- int16_t* SK_RESTRICT runs, SkAlpha* SK_RESTRICT aa) {
- // 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
- }
- SkAAClipBlitter::~SkAAClipBlitter() {
- sk_free(fScanlineScratch);
- }
- void SkAAClipBlitter::ensureRunsAndAA() {
- if (nullptr == fScanlineScratch) {
- // add 1 so we can store the terminating run count of 0
- int count = fAAClipBounds.width() + 1;
- // we use this either for fRuns + fAA, or a scaline of a mask
- // which may be as deep as 32bits
- fScanlineScratch = sk_malloc_throw(count * sizeof(SkPMColor));
- fRuns = (int16_t*)fScanlineScratch;
- fAA = (SkAlpha*)(fRuns + count);
- }
- }
- void SkAAClipBlitter::blitH(int x, int y, int width) {
- SkASSERT(width > 0);
- SkASSERT(fAAClipBounds.contains(x, y));
- SkASSERT(fAAClipBounds.contains(x + width - 1, y));
- const uint8_t* row = fAAClip->findRow(y);
- int initialCount;
- row = fAAClip->findX(row, x, &initialCount);
- if (initialCount >= width) {
- SkAlpha alpha = row[1];
- if (0 == alpha) {
- return;
- }
- if (0xFF == alpha) {
- fBlitter->blitH(x, y, width);
- return;
- }
- }
- this->ensureRunsAndAA();
- expandToRuns(row, initialCount, width, fRuns, fAA);
- fBlitter->blitAntiH(x, y, fAA, fRuns);
- }
- 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) {
- 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 = SkMin32(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;
- }
- void SkAAClipBlitter::blitAntiH(int x, int y, const SkAlpha aa[],
- const int16_t runs[]) {
- const uint8_t* row = fAAClip->findRow(y);
- int initialCount;
- row = fAAClip->findX(row, x, &initialCount);
- this->ensureRunsAndAA();
- merge(row, initialCount, aa, runs, fAA, fRuns, fAAClipBounds.width());
- fBlitter->blitAntiH(x, y, fAA, fRuns);
- }
- void SkAAClipBlitter::blitV(int x, int y, int height, SkAlpha alpha) {
- if (fAAClip->quickContains(x, y, x + 1, y + height)) {
- fBlitter->blitV(x, y, height, alpha);
- return;
- }
- for (;;) {
- int lastY SK_INIT_TO_AVOID_WARNING;
- const uint8_t* row = fAAClip->findRow(y, &lastY);
- int dy = lastY - y + 1;
- if (dy > height) {
- dy = height;
- }
- height -= dy;
- row = fAAClip->findX(row, x);
- SkAlpha newAlpha = SkMulDiv255Round(alpha, row[1]);
- if (newAlpha) {
- fBlitter->blitV(x, y, dy, newAlpha);
- }
- SkASSERT(height >= 0);
- if (height <= 0) {
- break;
- }
- y = lastY + 1;
- }
- }
- void SkAAClipBlitter::blitRect(int x, int y, int width, int height) {
- if (fAAClip->quickContains(x, y, x + width, y + height)) {
- fBlitter->blitRect(x, y, width, height);
- return;
- }
- while (--height >= 0) {
- this->blitH(x, y, width);
- y += 1;
- }
- }
- typedef void (*MergeAAProc)(const void* src, int width, const uint8_t* row,
- int initialRowCount, void* dst);
- static void small_memcpy(void* dst, const void* src, size_t n) {
- memcpy(dst, src, n);
- }
- static void small_bzero(void* dst, size_t n) {
- sk_bzero(dst, n);
- }
- static inline uint8_t mergeOne(uint8_t value, unsigned alpha) {
- return SkMulDiv255Round(value, alpha);
- }
- static inline uint16_t mergeOne(uint16_t value, unsigned alpha) {
- unsigned r = SkGetPackedR16(value);
- unsigned g = SkGetPackedG16(value);
- unsigned b = SkGetPackedB16(value);
- return SkPackRGB16(SkMulDiv255Round(r, alpha),
- SkMulDiv255Round(g, alpha),
- SkMulDiv255Round(b, alpha));
- }
- template <typename T>
- void mergeT(const void* inSrc, int srcN, const uint8_t* SK_RESTRICT row, int rowN, void* inDst) {
- 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 = SkMin32(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];
- }
- }
- static MergeAAProc find_merge_aa_proc(SkMask::Format format) {
- 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;
- }
- }
- static U8CPU bit2byte(int bitInAByte) {
- 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;
- }
- static void upscaleBW2A8(SkMask* dstMask, const SkMask& srcMask) {
- 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 = (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;
- }
- }
- void SkAAClipBlitter::blitMask(const SkMask& origMask, const SkIRect& clip) {
- SkASSERT(fAAClip->getBounds().contains(clip));
- if (fAAClip->quickContains(clip)) {
- fBlitter->blitMask(origMask, clip);
- return;
- }
- const SkMask* mask = &origMask;
- // if we're BW, we need to upscale to A8 (ugh)
- SkMask grayMask;
- if (SkMask::kBW_Format == origMask.fFormat) {
- grayMask.fFormat = SkMask::kA8_Format;
- grayMask.fBounds = origMask.fBounds;
- grayMask.fRowBytes = origMask.fBounds.width();
- size_t size = grayMask.computeImageSize();
- grayMask.fImage = (uint8_t*)fGrayMaskScratch.reset(size,
- SkAutoMalloc::kReuse_OnShrink);
- upscaleBW2A8(&grayMask, origMask);
- mask = &grayMask;
- }
- this->ensureRunsAndAA();
- // HACK -- we are devolving 3D into A8, need to copy the rest of the 3D
- // data into a temp block to support it better (ugh)
- const void* src = mask->getAddr(clip.fLeft, clip.fTop);
- const size_t srcRB = mask->fRowBytes;
- const int width = clip.width();
- MergeAAProc mergeProc = find_merge_aa_proc(mask->fFormat);
- SkMask rowMask;
- rowMask.fFormat = SkMask::k3D_Format == mask->fFormat ? SkMask::kA8_Format : mask->fFormat;
- rowMask.fBounds.fLeft = clip.fLeft;
- rowMask.fBounds.fRight = clip.fRight;
- rowMask.fRowBytes = mask->fRowBytes; // doesn't matter, since our height==1
- rowMask.fImage = (uint8_t*)fScanlineScratch;
- int y = clip.fTop;
- const int stopY = y + clip.height();
- do {
- int localStopY SK_INIT_TO_AVOID_WARNING;
- const uint8_t* row = fAAClip->findRow(y, &localStopY);
- // findRow returns last Y, not stop, so we add 1
- localStopY = SkMin32(localStopY + 1, stopY);
- int initialCount;
- row = fAAClip->findX(row, clip.fLeft, &initialCount);
- do {
- mergeProc(src, width, row, initialCount, rowMask.fImage);
- rowMask.fBounds.fTop = y;
- rowMask.fBounds.fBottom = y + 1;
- fBlitter->blitMask(rowMask, rowMask.fBounds);
- src = (const void*)((const char*)src + srcRB);
- } while (++y < localStopY);
- } while (y < stopY);
- }
- const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
- return nullptr;
- }
|