The Tor Browser / file revision

 /*

  * Copyright 2006 The Android Open Source Project

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #ifndef SkRegionPriv_DEFINED

 #define SkRegionPriv_DEFINED

 #include "SkRegion.h"

 #include "SkThread.h"

 #define assert_sentinel(value, isSentinel) \

     SkASSERT(((value) == SkRegion::kRunTypeSentinel) == isSentinel)

 //SkDEBUGCODE(extern int32_t gRgnAllocCounter;)

 #ifdef SK_DEBUG

 // Given the first interval (just past the interval-count), compute the

 // interval count, by search for the x-sentinel

 //

 static int compute_intervalcount(const SkRegion::RunType runs[]) {

     const SkRegion::RunType* curr = runs;

     while (*curr < SkRegion::kRunTypeSentinel) {

         SkASSERT(curr[0] < curr[1]);

         SkASSERT(curr[1] < SkRegion::kRunTypeSentinel);

         curr += 2;

     }

     return (curr - runs) >> 1;

 }

 #endif

 struct SkRegion::RunHead {

 private:

 public:

     int32_t fRefCnt;

     int32_t fRunCount;

     /**

      *  Number of spans with different Y values. This does not count the initial

      *  Top value, nor does it count the final Y-Sentinel value. In the logical

      *  case of a rectangle, this would return 1, and an empty region would

      *  return 0.

      */

     int getYSpanCount() const {

         return fYSpanCount;

     }

     /**

      *  Number of intervals in the entire region. This equals the number of

      *  rects that would be returned by the Iterator. In the logical case of

      *  a rect, this would return 1, and an empty region would return 0.

      */

     int getIntervalCount() const {

         return fIntervalCount;

     }

     static RunHead* Alloc(int count) {

         //SkDEBUGCODE(sk_atomic_inc(&gRgnAllocCounter);)

         //SkDEBUGF(("************** gRgnAllocCounter::alloc %d\n", gRgnAllocCounter));

         SkASSERT(count >= SkRegion::kRectRegionRuns);

         RunHead* head = (RunHead*)sk_malloc_throw(sizeof(RunHead) + count * sizeof(RunType));

         head->fRefCnt = 1;

         head->fRunCount = count;

         // these must be filled in later, otherwise we will be invalid

         head->fYSpanCount = 0;

         head->fIntervalCount = 0;

         return head;

     }

     static RunHead* Alloc(int count, int yspancount, int intervalCount) {

         SkASSERT(yspancount > 0);

         SkASSERT(intervalCount > 1);

         RunHead* head = Alloc(count);

         head->fYSpanCount = yspancount;

         head->fIntervalCount = intervalCount;

         return head;

     }

     SkRegion::RunType* writable_runs() {

         SkASSERT(fRefCnt == 1);

         return (SkRegion::RunType*)(this + 1);

     }

     const SkRegion::RunType* readonly_runs() const {

         return (const SkRegion::RunType*)(this + 1);

     }

     RunHead* ensureWritable() {

         RunHead* writable = this;

         if (fRefCnt > 1) {

             // We need to alloc & copy the current region before we call

             // sk_atomic_dec because it could be freed in the meantime,

             // otherwise.

             writable = Alloc(fRunCount, fYSpanCount, fIntervalCount);

             memcpy(writable->writable_runs(), this->readonly_runs(),

                    fRunCount * sizeof(RunType));

             // fRefCount might have changed since we last checked.

             // If we own the last reference at this point, we need to

             // free the memory.

             if (sk_atomic_dec(&fRefCnt) == 1) {

                 sk_free(this);

             }

         }

         return writable;

     }

     /**

      *  Given a scanline (including its Bottom value at runs[0]), return the next

      *  scanline. Asserts that there is one (i.e. runs[0] < Sentinel)

      */

     static SkRegion::RunType* SkipEntireScanline(const SkRegion::RunType runs[]) {

         // we are not the Y Sentinel

         SkASSERT(runs[0] < SkRegion::kRunTypeSentinel);

         const int intervals = runs[1];

         SkASSERT(runs[2 + intervals * 2] == SkRegion::kRunTypeSentinel);

 #ifdef SK_DEBUG

         {

             int n = compute_intervalcount(&runs[2]);

             SkASSERT(n == intervals);

         }

 #endif

         // skip the entire line [B N [L R] S]

         runs += 1 + 1 + intervals * 2 + 1;

         return const_cast<SkRegion::RunType*>(runs);

     }

     /**

      *  Return the scanline that contains the Y value. This requires that the Y

      *  value is already known to be contained within the bounds of the region,

      *  and so this routine never returns NULL.

      *

      *  It returns the beginning of the scanline, starting with its Bottom value.

      */

     SkRegion::RunType* findScanline(int y) const {

         const RunType* runs = this->readonly_runs();

         // if the top-check fails, we didn't do a quick check on the bounds

         SkASSERT(y >= runs[0]);

         runs += 1;  // skip top-Y

         for (;;) {

             int bottom = runs[0];

             // If we hit this, we've walked off the region, and our bounds check

             // failed.

             SkASSERT(bottom < SkRegion::kRunTypeSentinel);

             if (y < bottom) {

                 break;

             }

             runs = SkipEntireScanline(runs);

         }

         return const_cast<SkRegion::RunType*>(runs);

     }

     // Copy src runs into us, computing interval counts and bounds along the way

     void computeRunBounds(SkIRect* bounds) {

         RunType* runs = this->writable_runs();

         bounds->fTop = *runs++;

         int bot;

         int ySpanCount = 0;

         int intervalCount = 0;

         int left = SK_MaxS32;

         int rite = SK_MinS32;

         do {

             bot = *runs++;

             SkASSERT(bot < SkRegion::kRunTypeSentinel);

             ySpanCount += 1;

             const int intervals = *runs++;

             SkASSERT(intervals >= 0);

             SkASSERT(intervals < SkRegion::kRunTypeSentinel);

             if (intervals > 0) {

 #ifdef SK_DEBUG

                 {

                     int n = compute_intervalcount(runs);

                     SkASSERT(n == intervals);

                 }

 #endif

                 RunType L = runs[0];

                 SkASSERT(L < SkRegion::kRunTypeSentinel);

                 if (left > L) {

                     left = L;

                 }

                 runs += intervals * 2;

                 RunType R = runs[-1];

                 SkASSERT(R < SkRegion::kRunTypeSentinel);

                 if (rite < R) {

                     rite = R;

                 }

                 intervalCount += intervals;

             }

             SkASSERT(SkRegion::kRunTypeSentinel == *runs);

             runs += 1;  // skip x-sentinel

             // test Y-sentinel

         } while (SkRegion::kRunTypeSentinel > *runs);

 #ifdef SK_DEBUG

         // +1 to skip the last Y-sentinel

         int runCount = runs - this->writable_runs() + 1;

         SkASSERT(runCount == fRunCount);

 #endif

         fYSpanCount = ySpanCount;

         fIntervalCount = intervalCount;

         bounds->fLeft = left;

         bounds->fRight = rite;

         bounds->fBottom = bot;

     }

 private:

     int32_t fYSpanCount;

     int32_t fIntervalCount;

 };

 #endif