| /* |
| * Copyright 2008, The Android Open Source Project |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #define LOG_NDEBUG 0 |
| #define LOG_TAG "pictureset" |
| |
| //#include <config.h> |
| #include "CachedPrefix.h" |
| #include "android_graphics.h" |
| #include "PictureSet.h" |
| #include "SkBounder.h" |
| #include "SkCanvas.h" |
| #include "SkPicture.h" |
| #include "SkRect.h" |
| #include "SkRegion.h" |
| #include "SkStream.h" |
| #include "TimeCounter.h" |
| |
| #define MAX_DRAW_TIME 100 |
| #define MIN_SPLITTABLE 400 |
| #define MAX_ADDITIONAL_AREA 0.65 |
| #define MAX_ADDITIONAL_PICTURES 32 |
| |
| #define BUCKET_SIZE 1024 |
| #define MAX_BUCKET_COUNT_X 16 |
| #define MAX_BUCKET_COUNT_Y 64 |
| |
| #include <wtf/CurrentTime.h> |
| |
| #include <cutils/log.h> |
| #include <wtf/text/CString.h> |
| |
| #undef XLOGC |
| #define XLOGC(...) android_printLog(ANDROID_LOG_DEBUG, "PictureSet", __VA_ARGS__) |
| |
| #ifdef DEBUG |
| |
| #undef XLOG |
| #define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "PictureSet", __VA_ARGS__) |
| |
| #else |
| |
| #undef XLOG |
| #define XLOG(...) |
| |
| #endif // DEBUG |
| |
| #if PICTURE_SET_DEBUG |
| class MeasureStream : public SkWStream { |
| public: |
| MeasureStream() : mTotal(0) {} |
| virtual bool write(const void* , size_t size) { |
| mTotal += size; |
| return true; |
| } |
| size_t mTotal; |
| }; |
| #endif |
| |
| namespace android { |
| |
| PictureSet::PictureSet() : |
| #ifdef FAST_PICTURESET |
| mBucketSizeX(BUCKET_SIZE), mBucketSizeY(BUCKET_SIZE), |
| mBucketCountX(0), mBucketCountY(0), |
| #endif |
| mHeight(0), mWidth(0) |
| { |
| setDimensions(0, 0); |
| mBaseArea = mAdditionalArea = 0; |
| } |
| |
| PictureSet::PictureSet(SkPicture* picture) : |
| #ifdef FAST_PICTURESET |
| mBucketSizeX(BUCKET_SIZE), mBucketSizeY(BUCKET_SIZE), |
| mBucketCountX(0), mBucketCountY(0), |
| #endif |
| mHeight(0), mWidth(0) |
| { |
| mBaseArea = mAdditionalArea = 0; |
| if (!picture) { |
| setDimensions(0, 0); |
| return; |
| } |
| setDimensions(picture->width(), picture->height()); |
| mBaseArea = mWidth * mHeight; |
| #ifdef FAST_PICTURESET |
| SkIRect area; |
| area.set(0, 0, mWidth, mHeight); |
| splitAdd(area); |
| WTF::Vector<Bucket*>* buckets = bucketsToUpdate(); |
| for (unsigned int i = 0; i < buckets->size(); i++) { |
| Bucket* bucket = (*buckets)[i]; |
| for (unsigned int j = 0; j < bucket->size(); j++) { |
| BucketPicture& bucketPicture = (*bucket)[j]; |
| const SkIRect& inval = bucketPicture.mRealArea; |
| SkPicture *splitPicture = new SkPicture(); |
| SkCanvas *canvas = splitPicture->beginRecording( |
| inval.width(), inval.height(), |
| SkPicture::kUsePathBoundsForClip_RecordingFlag); |
| canvas->translate(-inval.fLeft, -inval.fTop); |
| picture->draw(canvas); |
| splitPicture->endRecording(); |
| SkSafeUnref(bucketPicture.mPicture); |
| bucketPicture.mPicture = splitPicture; |
| } |
| } |
| buckets->clear(); |
| #else |
| Pictures pictureAndBounds; |
| pictureAndBounds.mPicture = picture; |
| SkSafeRef(pictureAndBounds.mPicture); |
| pictureAndBounds.mEmpty = false; |
| pictureAndBounds.mArea.setRect(0, 0, mWidth, mHeight); |
| pictureAndBounds.mSplit = false; |
| pictureAndBounds.mBase = true; |
| pictureAndBounds.mElapsed = 0; |
| pictureAndBounds.mWroteElapsed = false; |
| mPictures.append(pictureAndBounds); |
| #endif // FAST_PICTURESET |
| } |
| |
| PictureSet::~PictureSet() |
| { |
| clear(); |
| } |
| |
| #ifdef FAST_PICTURESET |
| #else |
| void PictureSet::add(const Pictures* temp) |
| { |
| Pictures pictureAndBounds = *temp; |
| SkSafeRef(pictureAndBounds.mPicture); |
| pictureAndBounds.mWroteElapsed = false; |
| mPictures.append(pictureAndBounds); |
| } |
| #endif // FAST_PICTURESET |
| |
| void PictureSet::add(const SkRegion& area, SkPicture* picture, |
| uint32_t elapsed, bool split) |
| { |
| if (area.isRect()) { |
| #ifdef FAST_PICTURESET |
| splitAdd(area.getBounds()); |
| #else |
| add(area, picture, elapsed, split, false); |
| #endif // FAST_PICTURESET |
| } else { |
| SkRegion::Iterator cliperator(area); |
| while (!cliperator.done()) { |
| SkIRect ir = cliperator.rect(); |
| #ifdef FAST_PICTURESET |
| splitAdd(ir); |
| #else |
| SkRegion newArea; |
| newArea.setRect(ir); |
| add(newArea, picture, elapsed, split, false); |
| #endif // FAST_PICTURESET |
| cliperator.next(); |
| } |
| } |
| } |
| |
| #ifdef FAST_PICTURESET |
| |
| Bucket* PictureSet::getBucket(int x, int y) |
| { |
| // only create buckets for valid, positive coordinates, ignore and return |
| // NULL otherwise |
| if (x < 0 || y < 0) |
| return 0; |
| |
| BucketPosition position(x+1, y+1); |
| if (!mBuckets.contains(position)) { |
| XLOG("PictureSet::getBucket(%d, %d) adding new bucket", x, y); |
| Bucket* bucket = new Bucket(); |
| mBuckets.add(position, bucket); |
| } |
| return mBuckets.get(position); |
| } |
| |
| void PictureSet::displayBucket(Bucket* bucket) |
| { |
| BucketPicture* first = bucket->begin(); |
| BucketPicture* last = bucket->end(); |
| for (BucketPicture* current = first; current != last; current++) { |
| XLOGC("- in %x, bucketPicture %d,%d,%d,%d - %dx%d, picture: %x, base: %x", |
| bucket, |
| current->mArea.fLeft, |
| current->mArea.fTop, |
| current->mArea.fRight, |
| current->mArea.fBottom, |
| current->mArea.width(), |
| current->mArea.height(), |
| current->mPicture, |
| current->mBase); |
| } |
| } |
| |
| void PictureSet::displayBuckets() |
| { |
| XLOGC("\n\n****** DISPLAY BUCKETS ON PictureSet %x ******", this); |
| for (BucketMap::iterator iter = mBuckets.begin(); iter != mBuckets.end(); ++iter) { |
| XLOGC("\n*** Bucket %x for %d, %d", iter->second, iter->first.first, iter->first.second); |
| displayBucket(iter->second); |
| } |
| XLOGC("\n****** END OF DISPLAY BUCKETS ******\n\n"); |
| } |
| |
| // When we receive an inval in a Bucket, we try to see if we intersect with |
| // existing invals/pictures in the Bucket. |
| void PictureSet::addToBucket(Bucket* bucket, int dx, int dy, SkIRect& rect) |
| { |
| bool resetBase = false; |
| |
| SkIRect totalArea = rect; |
| BucketPicture* first = bucket->begin(); |
| BucketPicture* last = bucket->end(); |
| |
| // If the inval covers a large area of the base inval, let's repaint the |
| // entire bucket. |
| if (rect.width() * rect.height() > MAX_ADDITIONAL_AREA * mBucketSizeX * mBucketSizeY) |
| resetBase = true; |
| |
| // let's gather all the BucketPicture intersecting with the new invalidated |
| // area, collect their area and remove their picture |
| for (BucketPicture* current = first; current != last; current++) { |
| bool remove = resetBase; |
| bool intersect = false; |
| |
| if (!remove) |
| intersect = SkIRect::Intersects(current->mArea, rect); |
| // If the current picture is not a base, and we intersect, remove it |
| if (!remove && !current->mBase && intersect) |
| remove = true; |
| // If the current picture is a base, check if the new inval completely |
| // contains the base, and if so remove it. |
| if (!remove && current->mBase && rect.contains(current->mArea)) |
| remove = true; |
| // If the current picture is a base and it intersects, |
| // also check that it fully covers the bucket -- otherwise, |
| // let's aggregate it with the new inval. |
| if (!remove && current->mBase && intersect |
| && (current->mArea.width() < mBucketSizeX || current->mArea.height() < mBucketSizeY)) { |
| remove = true; |
| } |
| |
| if (remove) { |
| totalArea.join(current->mArea); |
| current->mBase = false; |
| current->mArea.setEmpty(); |
| SkSafeUnref(current->mPicture); |
| current->mPicture = 0; |
| } |
| } |
| |
| // Now, let's add the new BucketPicture to the list, with the correct |
| // area that needs to be repainted |
| SkRegion region; |
| SkIRect area = totalArea; |
| area.offset(dx, dy); |
| BucketPicture picture = { 0, totalArea, area, false }; |
| |
| bucket->append(picture); |
| |
| first = bucket->begin(); |
| last = bucket->end(); |
| |
| bool clearUp = false; |
| if (last - first > MAX_ADDITIONAL_PICTURES) { |
| // too many pictures in the bucket, let's collapse |
| clearUp = true; |
| } |
| |
| float bucketBaseArea = 0; |
| float bucketAdditionalArea = 0; |
| for (BucketPicture* current = first; current != last; current++) { |
| float area = current->mArea.width() * current->mArea.height(); |
| if (current->mBase) |
| bucketBaseArea += area; |
| else |
| bucketAdditionalArea += area; |
| } |
| |
| if (bucketBaseArea > 0 && bucketBaseArea * MAX_ADDITIONAL_AREA <= bucketAdditionalArea) { |
| // additional area too large, not worth maintaining |
| clearUp = true; |
| } |
| |
| // To clear things up, we just need to mark the pictures' area as empty |
| // We only keep the base surface. |
| if (clearUp) { |
| for (BucketPicture* current = first; current != last; current++) { |
| if (!current->mBase) |
| current->mArea.setEmpty(); |
| SkSafeUnref(current->mPicture); |
| current->mPicture = 0; |
| } |
| } |
| |
| // let's do a pass to collapse out empty areas |
| BucketPicture* writer = first; |
| for (BucketPicture* current = first; current != last; current++) { |
| if (current && current->mArea.isEmpty()) |
| continue; |
| *writer++ = *current; |
| } |
| |
| bucket->shrink(writer - first); |
| |
| // let's recompute the bases |
| first = bucket->begin(); |
| last = bucket->end(); |
| SkRegion drawn; |
| drawn.setEmpty(); |
| for (BucketPicture* current = first; current != last; current++) { |
| if (drawn.contains(current->mArea) == false) { |
| current->mBase = true; |
| } |
| drawn.op(current->mArea, SkRegion::kUnion_Op); |
| } |
| } |
| |
| void PictureSet::gatherBucketsForArea(WTF::Vector<Bucket*>& list, const SkIRect& rect) |
| { |
| XLOG("\n--- gatherBucketsForArea for rect %d, %d, %d, %d (%d x %d)", |
| rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, |
| rect.width(), rect.height()); |
| |
| if (!mBucketSizeX || !mBucketSizeY) { |
| XLOGC("PictureSet::gatherBucketsForArea() called with bad bucket size: x=%d y=%d", |
| mBucketSizeX, mBucketSizeY); |
| return; |
| } |
| |
| int x = rect.fLeft; |
| int y = rect.fTop; |
| int firstTileX = rect.fLeft / mBucketSizeX; |
| int firstTileY = rect.fTop / mBucketSizeY; |
| int lastTileX = rect.fRight / mBucketSizeX; |
| int lastTileY = rect.fBottom / mBucketSizeY; |
| |
| for (int i = firstTileX; i <= lastTileX; i++) { |
| for (int j = firstTileY; j <= lastTileY; j++) { |
| Bucket* bucket = getBucket(i, j); |
| XLOG("gather bucket %x for %d, %d", bucket, i+1, j+1); |
| if (bucket) |
| list.append(bucket); |
| } |
| } |
| } |
| |
| // When we receive a new inval rect, we first find the Buckets that intersect |
| // with it; then we split the original inval into a serie of invals (one for |
| // each Bucket we intersect with). We then send that inval to the Bucket. |
| void PictureSet::splitAdd(const SkIRect& rect) |
| { |
| XLOG("\n--- splitAdd for rect %d, %d, %d, %d (%d x %d)", |
| rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, |
| rect.width(), rect.height()); |
| |
| if (!mBucketSizeX || !mBucketSizeY) { |
| XLOGC("PictureSet::splitAdd() called with bad bucket size: x=%d y=%d", |
| mBucketSizeX, mBucketSizeY); |
| return; |
| } |
| |
| // TODO: reuse gatherBucketsForArea() (change Bucket to be a class) |
| int x = rect.fLeft; |
| int y = rect.fTop; |
| int firstTileX = rect.fLeft / mBucketSizeX; |
| int firstTileY = rect.fTop / mBucketSizeY; |
| int lastTileX = rect.fRight / mBucketSizeX; |
| int lastTileY = rect.fBottom / mBucketSizeY; |
| |
| XLOG("--- firstTile(%d, %d) lastTile(%d, %d)", |
| firstTileX, firstTileY, |
| lastTileX, lastTileY); |
| |
| for (int i = firstTileX; i <= lastTileX; i++) { |
| for (int j = firstTileY; j <= lastTileY; j++) { |
| Bucket* bucket = getBucket(i, j); |
| if (!bucket) |
| continue; |
| |
| SkIRect newRect; |
| int deltaX = i * mBucketSizeX; |
| int deltaY = j * mBucketSizeY; |
| int left = (i == firstTileX) ? rect.fLeft - deltaX : 0; |
| int top = (j == firstTileY) ? rect.fTop - deltaY : 0; |
| int right = (i == lastTileX) ? rect.fRight % mBucketSizeX : mBucketSizeX; |
| int bottom = (j == lastTileY) ? rect.fBottom % mBucketSizeY : mBucketSizeY; |
| |
| newRect.set(left, top, right, bottom); |
| addToBucket(bucket, deltaX, deltaY, newRect); |
| mUpdatedBuckets.append(bucket); |
| } |
| } |
| |
| XLOG("--- splitAdd DONE\n"); |
| } |
| |
| #endif // FAST_PICTURESET |
| |
| // This function is used to maintain the list of Pictures. |
| // Pictures contain an SkPicture covering a specific area; some |
| // Pictures are "base" Pictures -- i.e. there is no Pictures |
| // underneath them. |
| // The idea here is to keep a balance between the number of Pictures |
| // we have (more Pictures slow us down) and the area of Pictures that |
| // need to be repainted (obviously, smaller areas are better). |
| // To do so, we try to not update/repaint the base pictures -- by |
| // construction, they usually cover a large area (the entire page). |
| // We only reset a base picture if the new invalidated area entirely |
| // contains it. |
| // Most of the time we thus work on smaller pictures on top of the |
| // base ones; We compute the total area of all pictures intersecting |
| // with the passed invalidated area (as they would need to be invalidated), |
| // and use that as the basis for the correct area we want to invalidate |
| // (we then can simply delete the pictures we intersect with). |
| // In addition, we do a couple of things to limit the total number of pictures |
| // we keep in the list: |
| // - if the total area of additional textures reach 65% of the base pictures, |
| // we delete the additional pictures and mark the base pictures as |
| // needing a full repaint |
| // - we limit the number of pictures to 32 -- above that, we do the same |
| // things (deleting additional pictures + full repaint of base pictures) |
| #ifdef FAST_PICTURESET |
| #else |
| void PictureSet::add(const SkRegion& area, SkPicture* picture, |
| uint32_t elapsed, bool split, bool empty) |
| { |
| bool checkForNewBases = false; |
| |
| Pictures* first = mPictures.begin(); |
| Pictures* last = mPictures.end(); |
| #ifdef DEBUG |
| XLOG("--- before adding the new inval ---"); |
| for (Pictures* working = mPictures.begin(); working != mPictures.end(); working++) { |
| SkIRect currentArea = working->mArea.getBounds(); |
| XLOG("picture %d (%d, %d, %d, %d - %d x %d) (isRect? %c) base: %c", |
| working - first, |
| currentArea.fLeft, currentArea.fTop, currentArea.fRight, currentArea.fBottom, |
| currentArea.width(), currentArea.height(), |
| working->mArea.isRect() ? 'Y' : 'N', |
| working->mBase ? 'Y' : 'N'); |
| } |
| XLOG("----------------------------------"); |
| #endif |
| |
| // let's gather all the Pictures intersecting with the new invalidated |
| // area, collect their area and remove their picture |
| SkIRect totalArea = area.getBounds(); |
| for (Pictures* working = first; working != last; working++) { |
| SkIRect inval = area.getBounds(); |
| bool remove = false; |
| if (!working->mBase && working->mArea.intersects(inval)) |
| remove = true; |
| if (working->mBase) { |
| SkIRect baseArea = working->mArea.getBounds(); |
| if (area.contains(baseArea)) { |
| remove = true; |
| checkForNewBases = true; |
| } |
| } |
| |
| if (remove) { |
| SkIRect currentArea = working->mArea.getBounds(); |
| if (working->mBase) |
| mBaseArea -= currentArea.width() * currentArea.height(); |
| else |
| mAdditionalArea -= currentArea.width() * currentArea.height(); |
| |
| totalArea.join(currentArea); |
| XLOG("picture %d (%d, %d, %d, %d - %d x %d) (isRect? %c) intersects with the new inval area (%d, %d, %d, %d - %d x %d) (isRect? %c, we remove it", |
| working - first, |
| currentArea.fLeft, currentArea.fTop, currentArea.fRight, currentArea.fBottom, |
| currentArea.width(), currentArea.height(), |
| working->mArea.isRect() ? 'Y' : 'N', |
| inval.fLeft, inval.fTop, inval.fRight, inval.fBottom, |
| inval.width(), inval.height(), |
| area.isRect() ? 'Y' : 'N'); |
| working->mArea.setEmpty(); |
| SkSafeUnref(working->mPicture); |
| working->mPicture = 0; |
| } |
| } |
| |
| // Now we can add the new Picture to the list, with the correct area |
| // that need to be repainted |
| SkRegion collect; |
| collect.setRect(totalArea); |
| Pictures pictureAndBounds = {collect, 0, collect.getBounds(), |
| elapsed, split, false, false, empty}; |
| |
| #ifdef FAST_PICTURESET |
| if (mPictures.size() == 0) |
| checkForNewBases = true; |
| #endif |
| |
| mPictures.append(pictureAndBounds); |
| mAdditionalArea += totalArea.width() * totalArea.height(); |
| last = mPictures.end(); |
| first = mPictures.begin(); |
| |
| // Then, let's see if we have to clear up the pictures in order to keep |
| // the total number of pictures under our limit |
| bool clearUp = false; |
| if (last - first > MAX_ADDITIONAL_PICTURES) { |
| XLOG("--- too many pictures, only keeping the bases : %d", last - first); |
| clearUp = true; |
| } |
| |
| if (!clearUp) { |
| if (mBaseArea > 0 && mBaseArea * MAX_ADDITIONAL_AREA <= mAdditionalArea) { |
| XLOG("+++ the sum of the additional area is > %.2f\% of the base Area (%.2f (%.2f) <= %.2f", |
| MAX_ADDITIONAL_AREA * 100, mBaseArea * 0.65, mBaseArea, mAdditionalArea); |
| clearUp = true; |
| } |
| } |
| |
| if (clearUp) { |
| for (Pictures* working = mPictures.begin(); working != mPictures.end(); working++) { |
| if (!working->mBase) |
| working->mArea.setEmpty(); |
| SkSafeUnref(working->mPicture); |
| working->mPicture = 0; |
| } |
| } |
| |
| #ifdef DEBUG |
| XLOG("--- after adding the new inval, but before collapsing ---"); |
| for (Pictures* working = mPictures.begin(); working != mPictures.end(); working++) { |
| SkIRect currentArea = working->mArea.getBounds(); |
| XLOG("picture %d (%d, %d, %d, %d - %d x %d) (isRect? %c) base: %c", |
| working - first, |
| currentArea.fLeft, currentArea.fTop, currentArea.fRight, currentArea.fBottom, |
| currentArea.width(), currentArea.height(), |
| working->mArea.isRect() ? 'Y' : 'N', |
| working->mBase ? 'Y' : 'N'); |
| } |
| XLOG("----------------------------------"); |
| XLOG("let's collapse..."); |
| #endif |
| |
| // Finally, let's do a pass to collapse out empty regions |
| Pictures* writer = first; |
| for (Pictures* working = first; working != last; working++) { |
| if (working && working->mArea.isEmpty()) |
| continue; |
| *writer++ = *working; |
| } |
| XLOG("shiking of %d elements", writer - first); |
| mPictures.shrink(writer - first); |
| |
| #ifdef DEBUG |
| XLOG("--- after adding the new inval ---"); |
| for (Pictures* working = mPictures.begin(); working != mPictures.end(); working++) { |
| SkIRect currentArea = working->mArea.getBounds(); |
| XLOG("picture %d (%d, %d, %d, %d - %d x %d) (isRect? %c) base: %c picture %x", |
| working - first, |
| currentArea.fLeft, currentArea.fTop, currentArea.fRight, currentArea.fBottom, |
| currentArea.width(), currentArea.height(), |
| working->mArea.isRect() ? 'Y' : 'N', |
| working->mBase ? 'Y' : 'N', working->mPicture); |
| } |
| XLOG("----------------------------------"); |
| #endif |
| |
| // Base pictures might have been removed/added -- let's recompute them |
| SkRegion drawn; |
| if (checkForNewBases) { |
| drawn.setEmpty(); |
| Pictures* last = mPictures.end(); |
| XLOG("checkForNewBases..."); |
| for (Pictures* working = mPictures.begin(); working != last; working++) { |
| SkRegion& area = working->mArea; |
| const SkIRect& a = area.getBounds(); |
| if (drawn.contains(working->mArea) == false) { |
| working->mBase = true; |
| float area = a.width() * a.height(); |
| mBaseArea += area; |
| mAdditionalArea -= area; |
| } |
| drawn.op(working->mArea, SkRegion::kUnion_Op); |
| } |
| } |
| } |
| #endif // FAST_PICTURESET |
| |
| void PictureSet::setDimensions(int width, int height, SkRegion* inval) |
| { |
| // Note that setDimensions() may be called by our ctor and should behave accordingly |
| if (mWidth == width && mHeight == height) |
| return; |
| DBG_SET_LOGD("%p old:(w=%d,h=%d) new:(w=%d,h=%d)", this, |
| mWidth, mHeight, width, height); |
| bool clearCache = false; |
| if (inval) { |
| if (mWidth == width && height > mHeight) { // only grew vertically |
| SkIRect rect; |
| rect.set(0, mHeight, width, height); |
| inval->op(rect, SkRegion::kUnion_Op); |
| } else { |
| clearCache = true; |
| inval->setRect(0, 0, width, height); |
| } |
| } |
| #ifdef FAST_PICTURESET |
| // First figure out how large each bucket would be if we used all of the buckets |
| int tmpSizeX = (width + MAX_BUCKET_COUNT_X - 1) / MAX_BUCKET_COUNT_X; |
| int tmpSizeY = (height + MAX_BUCKET_COUNT_Y - 1) / MAX_BUCKET_COUNT_Y; |
| |
| // Then round the bucket size up to the nearest chunk |
| int bucketSizeX = ((tmpSizeX - 1) / BUCKET_SIZE + 1) * BUCKET_SIZE; |
| int bucketSizeY = ((tmpSizeY - 1) / BUCKET_SIZE + 1) * BUCKET_SIZE; |
| |
| int bucketCountX = (width + bucketSizeX - 1) / bucketSizeX; |
| int bucketCountY = (height + bucketSizeY - 1) / bucketSizeY; |
| |
| // Clear the cache if the horizontal bucket count changed or the vertical |
| // count shrank |
| if (bucketCountX != mBucketCountX || bucketCountY < mBucketCountY) |
| clearCache = true; |
| |
| // Or if the bucket size changed |
| if (bucketSizeX != mBucketSizeX || bucketSizeY != mBucketSizeY) |
| clearCache = true; |
| |
| XLOG("old width=%d height=%d bucketSizeX=%d bucketSizeY=%d bucketCountX=%d bucketCountY=%d clearCache=%d", |
| mWidth, mHeight, mBucketSizeX, mBucketSizeY, mBucketCountX, mBucketCountY, clearCache); |
| XLOG("new width=%d height=%d bucketSizeX=%d bucketSizeY=%d bucketCountX=%d bucketCountY=%d clearCache=%d", |
| width, height, bucketSizeX, bucketSizeY, bucketCountX, bucketCountY, clearCache); |
| #endif |
| if (clearCache) |
| clear(); |
| mWidth = width; |
| mHeight = height; |
| #ifdef FAST_PICTURESET |
| mBucketSizeX = bucketSizeX; |
| mBucketSizeY = bucketSizeY; |
| mBucketCountX = bucketCountX; |
| mBucketCountY = bucketCountY; |
| #endif |
| } |
| |
| void PictureSet::clear() |
| { |
| DBG_SET_LOG(""); |
| #ifdef FAST_PICTURESET |
| for (BucketMap::iterator iter = mBuckets.begin(); iter != mBuckets.end(); ++iter) { |
| Bucket* bucket = iter->second; |
| BucketPicture* first = bucket->begin(); |
| BucketPicture* last = bucket->end(); |
| for (BucketPicture* current = first; current != last; current++) { |
| SkSafeUnref(current->mPicture); |
| current->mPicture = 0; |
| } |
| bucket->clear(); |
| } |
| mBuckets.clear(); |
| mBucketSizeX = mBucketSizeY = BUCKET_SIZE; |
| #else |
| Pictures* last = mPictures.end(); |
| for (Pictures* working = mPictures.begin(); working != last; working++) { |
| working->mArea.setEmpty(); |
| SkSafeUnref(working->mPicture); |
| } |
| mPictures.clear(); |
| #endif // FAST_PICTURESET |
| mWidth = mHeight = 0; |
| } |
| |
| bool PictureSet::draw(SkCanvas* canvas) |
| { |
| #ifdef FAST_PICTURESET |
| XLOG("PictureSet %x draw on canvas %x", this, canvas); |
| SkRect bounds; |
| if (canvas->getClipBounds(&bounds) == false) |
| return false; |
| SkIRect irect; |
| bounds.roundOut(&irect); |
| |
| WTF::Vector<Bucket*> list; |
| gatherBucketsForArea(list, irect); |
| |
| XLOG("PictureSet draw on canvas %x, we have %d buckets", canvas, list.size()); |
| for (unsigned int i = 0; i < list.size(); i++) { |
| Bucket* bucket = list[i]; |
| XLOG("We paint using bucket %x with %d pictures", bucket, bucket->size()); |
| for (unsigned int j = 0; j < bucket->size(); j++) { |
| BucketPicture& picture = bucket->at(j); |
| if (!picture.mPicture) |
| continue; |
| int saved = canvas->save(); |
| SkRect pathBounds; |
| pathBounds.set(picture.mRealArea); |
| XLOG("[%d/%d] draw on canvas with clip %d, %d, %d, %d - %d x %d", |
| j, bucket->size(), |
| picture.mRealArea.fLeft, |
| picture.mRealArea.fTop, |
| picture.mRealArea.fRight, |
| picture.mRealArea.fBottom, |
| picture.mRealArea.width(), |
| picture.mRealArea.height()); |
| canvas->clipRect(pathBounds); |
| canvas->translate(pathBounds.fLeft, pathBounds.fTop); |
| canvas->save(); |
| canvas->drawPicture(*picture.mPicture); |
| canvas->restoreToCount(saved); |
| } |
| } |
| return false; |
| |
| #else |
| |
| validate(__FUNCTION__); |
| Pictures* first = mPictures.begin(); |
| Pictures* last = mPictures.end(); |
| Pictures* working; |
| SkRect bounds; |
| if (canvas->getClipBounds(&bounds) == false) |
| return false; |
| SkIRect irect; |
| bounds.roundOut(&irect); |
| for (working = last; working != first; ) { |
| --working; |
| if (working->mArea.contains(irect)) { |
| #if PICTURE_SET_DEBUG |
| const SkIRect& b = working->mArea.getBounds(); |
| DBG_SET_LOGD("contains working->mArea={%d,%d,%d,%d}" |
| " irect={%d,%d,%d,%d}", b.fLeft, b.fTop, b.fRight, b.fBottom, |
| irect.fLeft, irect.fTop, irect.fRight, irect.fBottom); |
| #endif |
| first = working; |
| break; |
| } |
| } |
| DBG_SET_LOGD("%p first=%d last=%d", this, first - mPictures.begin(), |
| last - mPictures.begin()); |
| uint32_t maxElapsed = 0; |
| for (working = first; working != last; working++) { |
| const SkRegion& area = working->mArea; |
| if (area.quickReject(irect)) { |
| #if PICTURE_SET_DEBUG |
| const SkIRect& b = area.getBounds(); |
| DBG_SET_LOGD("[%d] %p quickReject working->mArea={%d,%d,%d,%d}" |
| " irect={%d,%d,%d,%d}", working - first, working, |
| b.fLeft, b.fTop, b.fRight, b.fBottom, |
| irect.fLeft, irect.fTop, irect.fRight, irect.fBottom); |
| #endif |
| working->mElapsed = 0; |
| continue; |
| } |
| int saved = canvas->save(); |
| SkRect pathBounds; |
| if (area.isComplex()) { |
| SkPath pathClip; |
| area.getBoundaryPath(&pathClip); |
| canvas->clipPath(pathClip); |
| pathBounds = pathClip.getBounds(); |
| } else { |
| pathBounds.set(area.getBounds()); |
| canvas->clipRect(pathBounds); |
| } |
| canvas->translate(pathBounds.fLeft, pathBounds.fTop); |
| canvas->save(); |
| uint32_t startTime = getThreadMsec(); |
| canvas->drawPicture(*working->mPicture); |
| size_t elapsed = working->mElapsed = getThreadMsec() - startTime; |
| working->mWroteElapsed = true; |
| if (maxElapsed < elapsed && (pathBounds.width() >= MIN_SPLITTABLE || |
| pathBounds.height() >= MIN_SPLITTABLE)) |
| maxElapsed = elapsed; |
| canvas->restoreToCount(saved); |
| #define DRAW_TEST_IMAGE 01 |
| #if DRAW_TEST_IMAGE && PICTURE_SET_DEBUG |
| SkColor color = 0x3f000000 | (0xffffff & (unsigned) working); |
| canvas->drawColor(color); |
| SkPaint paint; |
| color ^= 0x00ffffff; |
| paint.setColor(color); |
| char location[256]; |
| for (int x = area.getBounds().fLeft & ~0x3f; |
| x < area.getBounds().fRight; x += 0x40) { |
| for (int y = area.getBounds().fTop & ~0x3f; |
| y < area.getBounds().fBottom; y += 0x40) { |
| int len = snprintf(location, sizeof(location) - 1, "(%d,%d)", x, y); |
| canvas->drawText(location, len, x, y, paint); |
| } |
| } |
| #endif |
| DBG_SET_LOGD("[%d] %p working->mArea={%d,%d,%d,%d} elapsed=%d base=%s", |
| working - first, working, |
| area.getBounds().fLeft, area.getBounds().fTop, |
| area.getBounds().fRight, area.getBounds().fBottom, |
| working->mElapsed, working->mBase ? "true" : "false"); |
| } |
| // dump(__FUNCTION__); |
| return maxElapsed >= MAX_DRAW_TIME; |
| #endif // FAST_PICTURESET |
| } |
| |
| void PictureSet::dump(const char* label) const |
| { |
| #if PICTURE_SET_DUMP |
| DBG_SET_LOGD("%p %s (%d) (w=%d,h=%d)", this, label, mPictures.size(), |
| mWidth, mHeight); |
| const Pictures* last = mPictures.end(); |
| for (const Pictures* working = mPictures.begin(); working != last; working++) { |
| const SkIRect& bounds = working->mArea.getBounds(); |
| const SkIRect& unsplit = working->mUnsplit; |
| MeasureStream measure; |
| if (working->mPicture != NULL) |
| working->mPicture->serialize(&measure); |
| LOGD(" [%d]" |
| " mArea.bounds={%d,%d,r=%d,b=%d}" |
| " mPicture=%p" |
| " mUnsplit={%d,%d,r=%d,b=%d}" |
| " mElapsed=%d" |
| " mSplit=%s" |
| " mWroteElapsed=%s" |
| " mBase=%s" |
| " pict-size=%d", |
| working - mPictures.begin(), |
| bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom, |
| working->mPicture, |
| unsplit.fLeft, unsplit.fTop, unsplit.fRight, unsplit.fBottom, |
| working->mElapsed, working->mSplit ? "true" : "false", |
| working->mWroteElapsed ? "true" : "false", |
| working->mBase ? "true" : "false", |
| measure.mTotal); |
| } |
| #endif |
| } |
| |
| class IsEmptyBounder : public SkBounder { |
| virtual bool onIRect(const SkIRect& rect) { |
| return false; |
| } |
| }; |
| |
| class IsEmptyCanvas : public SkCanvas { |
| public: |
| IsEmptyCanvas(SkBounder* bounder, SkPicture* picture) : |
| mPicture(picture), mEmpty(true) { |
| setBounder(bounder); |
| } |
| |
| void notEmpty() { |
| mEmpty = false; |
| mPicture->abortPlayback(); |
| } |
| |
| virtual bool clipPath(const SkPath&, SkRegion::Op) { |
| // this can be expensive to actually do, and doesn't affect the |
| // question of emptiness, so we make it a no-op |
| return true; |
| } |
| |
| virtual void commonDrawBitmap(const SkBitmap& bitmap, const SkIRect* rect, |
| const SkMatrix& , const SkPaint& ) { |
| if (bitmap.width() <= 1 || bitmap.height() <= 1) |
| return; |
| DBG_SET_LOGD("abort {%d,%d}", bitmap.width(), bitmap.height()); |
| notEmpty(); |
| } |
| |
| virtual void drawPaint(const SkPaint& paint) { |
| } |
| |
| virtual void drawPath(const SkPath& , const SkPaint& paint) { |
| DBG_SET_LOG("abort"); |
| notEmpty(); |
| } |
| |
| virtual void drawPoints(PointMode , size_t , const SkPoint [], |
| const SkPaint& paint) { |
| } |
| |
| virtual void drawRect(const SkRect& , const SkPaint& paint) { |
| // wait for visual content |
| if (paint.getColor() != SK_ColorWHITE) |
| notEmpty(); |
| } |
| |
| virtual void drawSprite(const SkBitmap& , int , int , |
| const SkPaint* paint = NULL) { |
| DBG_SET_LOG("abort"); |
| notEmpty(); |
| } |
| |
| virtual void drawText(const void* , size_t byteLength, SkScalar , |
| SkScalar , const SkPaint& paint) { |
| DBG_SET_LOGD("abort %d", byteLength); |
| notEmpty(); |
| } |
| |
| virtual void drawPosText(const void* , size_t byteLength, |
| const SkPoint [], const SkPaint& paint) { |
| DBG_SET_LOGD("abort %d", byteLength); |
| notEmpty(); |
| } |
| |
| virtual void drawPosTextH(const void* , size_t byteLength, |
| const SkScalar [], SkScalar , |
| const SkPaint& paint) { |
| DBG_SET_LOGD("abort %d", byteLength); |
| notEmpty(); |
| } |
| |
| virtual void drawTextOnPath(const void* , size_t byteLength, |
| const SkPath& , const SkMatrix* , |
| const SkPaint& paint) { |
| DBG_SET_LOGD("abort %d", byteLength); |
| notEmpty(); |
| } |
| |
| virtual void drawPicture(SkPicture& picture) { |
| SkCanvas::drawPicture(picture); |
| } |
| |
| SkPicture* mPicture; |
| bool mEmpty; |
| }; |
| |
| bool PictureSet::emptyPicture(SkPicture* picture) const |
| { |
| IsEmptyBounder isEmptyBounder; |
| IsEmptyCanvas checker(&isEmptyBounder, picture); |
| SkBitmap bitmap; |
| bitmap.setConfig(SkBitmap::kARGB_8888_Config, mWidth, mHeight); |
| checker.setBitmapDevice(bitmap); |
| checker.drawPicture(*picture); |
| return checker.mEmpty; |
| } |
| |
| bool PictureSet::isEmpty() const |
| { |
| #ifdef FAST_PICTURESET |
| // For now, just assume the pictureset is *not* empty |
| // if the hashmap contains something |
| for (BucketMap::const_iterator iter = mBuckets.begin(); iter != mBuckets.end(); ++iter) { |
| if (iter->second->size() > 0) |
| return false; |
| } |
| return true; |
| #else |
| const Pictures* last = mPictures.end(); |
| for (const Pictures* working = mPictures.begin(); working != last; working++) { |
| if (!working->mEmpty) |
| return false; |
| } |
| return true; |
| #endif // FAST_PICTURESET |
| } |
| |
| void PictureSet::set(const PictureSet& src) |
| { |
| DBG_SET_LOGD("start %p src=%p", this, &src); |
| clear(); |
| setDimensions(src.mWidth, src.mHeight); |
| #ifdef FAST_PICTURESET |
| XLOG("\n--- set picture ---"); |
| for (BucketMap::const_iterator iter = src.mBuckets.begin(); |
| iter != src.mBuckets.end(); ++iter) { |
| Bucket* sourceBucket = iter->second; |
| Bucket* targetBucket = getBucket(iter->first.first-1, iter->first.second-1); |
| BucketPicture* first = sourceBucket->begin(); |
| BucketPicture* last = sourceBucket->end(); |
| XLOG("set from bucket %x (%d, %d), %d pictures", sourceBucket, |
| iter->first.first, iter->first.second, sourceBucket->size()); |
| for (BucketPicture* current = first; current != last; current++) { |
| XLOG("set picture %x from bucket %x in bucket %x (%d, %d)", |
| current->mPicture, sourceBucket, targetBucket, |
| iter->first.first, iter->first.second); |
| SkSafeRef(current->mPicture); |
| BucketPicture picture = { current->mPicture, current->mArea, |
| current->mRealArea, current->mBase }; |
| targetBucket->append(picture); |
| } |
| } |
| XLOG("--- DONE set picture ---\n"); |
| #else |
| const Pictures* last = src.mPictures.end(); |
| for (const Pictures* working = src.mPictures.begin(); working != last; working++) |
| add(working); |
| // dump(__FUNCTION__); |
| validate(__FUNCTION__); |
| DBG_SET_LOG("end"); |
| #endif // FAST_PICTURESET |
| } |
| |
| #ifdef FAST_PICTURESET |
| #else |
| |
| bool PictureSet::reuseSubdivided(const SkRegion& inval) |
| { |
| validate(__FUNCTION__); |
| |
| if (inval.isComplex()) |
| return false; |
| Pictures* working, * last = mPictures.end(); |
| const SkIRect& invalBounds = inval.getBounds(); |
| bool steal = false; |
| for (working = mPictures.begin(); working != last; working++) { |
| if (working->mSplit && invalBounds == working->mUnsplit) { |
| steal = true; |
| continue; |
| } |
| if (steal == false) |
| continue; |
| SkRegion temp = SkRegion(inval); |
| temp.op(working->mArea, SkRegion::kIntersect_Op); |
| if (temp.isEmpty() || temp == working->mArea) |
| continue; |
| return false; |
| } |
| if (steal == false) |
| return false; |
| for (working = mPictures.begin(); working != last; working++) { |
| if ((working->mSplit == false || invalBounds != working->mUnsplit) && |
| inval.contains(working->mArea) == false) |
| continue; |
| SkSafeUnref(working->mPicture); |
| working->mPicture = NULL; |
| } |
| return true; |
| } |
| |
| void PictureSet::setDrawTimes(const PictureSet& src) |
| { |
| validate(__FUNCTION__); |
| if (mWidth != src.mWidth || mHeight != src.mHeight) |
| return; |
| Pictures* last = mPictures.end(); |
| Pictures* working = mPictures.begin(); |
| if (working == last) |
| return; |
| const Pictures* srcLast = src.mPictures.end(); |
| const Pictures* srcWorking = src.mPictures.begin(); |
| for (; srcWorking != srcLast; srcWorking++) { |
| if (srcWorking->mWroteElapsed == false) |
| continue; |
| while ((srcWorking->mArea != working->mArea || |
| srcWorking->mPicture != working->mPicture)) { |
| if (++working == last) |
| return; |
| } |
| DBG_SET_LOGD("%p [%d] [%d] {%d,%d,r=%d,b=%d} working->mElapsed=%d <- %d", |
| this, working - mPictures.begin(), srcWorking - src.mPictures.begin(), |
| working->mArea.getBounds().fLeft, working->mArea.getBounds().fTop, |
| working->mArea.getBounds().fRight, working->mArea.getBounds().fBottom, |
| working->mElapsed, srcWorking->mElapsed); |
| working->mElapsed = srcWorking->mElapsed; |
| } |
| } |
| |
| void PictureSet::setPicture(size_t i, SkPicture* p) |
| { |
| SkSafeUnref(mPictures[i].mPicture); |
| mPictures[i].mPicture = p; |
| mPictures[i].mEmpty = emptyPicture(p); |
| } |
| |
| void PictureSet::split(PictureSet* out) const |
| { |
| dump(__FUNCTION__); |
| DBG_SET_LOGD("%p", this); |
| SkIRect totalBounds; |
| out->mWidth = mWidth; |
| out->mHeight = mHeight; |
| totalBounds.set(0, 0, mWidth, mHeight); |
| SkRegion* total = new SkRegion(totalBounds); |
| const Pictures* last = mPictures.end(); |
| const Pictures* working; |
| uint32_t balance = 0; |
| int multiUnsplitFastPictures = 0; // > 1 has more than 1 |
| for (working = mPictures.begin(); working != last; working++) { |
| if (working->mElapsed >= MAX_DRAW_TIME || working->mSplit) |
| continue; |
| if (++multiUnsplitFastPictures > 1) |
| break; |
| } |
| for (working = mPictures.begin(); working != last; working++) { |
| uint32_t elapsed = working->mElapsed; |
| if (elapsed < MAX_DRAW_TIME) { |
| bool split = working->mSplit; |
| DBG_SET_LOGD("elapsed=%d working=%p total->getBounds()=" |
| "{%d,%d,r=%d,b=%d} split=%s", elapsed, working, |
| total->getBounds().fLeft, total->getBounds().fTop, |
| total->getBounds().fRight, total->getBounds().fBottom, |
| split ? "true" : "false"); |
| if (multiUnsplitFastPictures <= 1 || split) { |
| total->op(working->mArea, SkRegion::kDifference_Op); |
| out->add(working->mArea, working->mPicture, elapsed, split, |
| working->mEmpty); |
| } else if (balance < elapsed) |
| balance = elapsed; |
| continue; |
| } |
| total->op(working->mArea, SkRegion::kDifference_Op); |
| const SkIRect& bounds = working->mArea.getBounds(); |
| int width = bounds.width(); |
| int height = bounds.height(); |
| int across = 1; |
| int down = 1; |
| while (height >= MIN_SPLITTABLE || width >= MIN_SPLITTABLE) { |
| if (height >= width) { |
| height >>= 1; |
| down <<= 1; |
| } else { |
| width >>= 1; |
| across <<= 1 ; |
| } |
| if ((elapsed >>= 1) < MAX_DRAW_TIME) |
| break; |
| } |
| width = bounds.width(); |
| height = bounds.height(); |
| int top = bounds.fTop; |
| for (int indexY = 0; indexY < down; ) { |
| int bottom = bounds.fTop + height * ++indexY / down; |
| int left = bounds.fLeft; |
| for (int indexX = 0; indexX < across; ) { |
| int right = bounds.fLeft + width * ++indexX / across; |
| SkIRect cBounds; |
| cBounds.set(left, top, right, bottom); |
| out->add(SkRegion(cBounds), (across | down) != 1 ? NULL : |
| working->mPicture, elapsed, true, |
| (across | down) != 1 ? false : working->mEmpty); |
| left = right; |
| } |
| top = bottom; |
| } |
| } |
| DBG_SET_LOGD("%p w=%d h=%d total->isEmpty()=%s multiUnsplitFastPictures=%d", |
| this, mWidth, mHeight, total->isEmpty() ? "true" : "false", |
| multiUnsplitFastPictures); |
| if (!total->isEmpty() && multiUnsplitFastPictures > 1) |
| out->add(*total, NULL, balance, false, false); |
| delete total; |
| validate(__FUNCTION__); |
| out->dump("split-out"); |
| } |
| |
| #endif // FAST_PICTURESET |
| |
| bool PictureSet::validate(const char* funct) const |
| { |
| #ifdef FAST_PICTURESET |
| return true; |
| #else |
| bool valid = true; |
| #if PICTURE_SET_VALIDATE |
| SkRegion all; |
| const Pictures* first = mPictures.begin(); |
| for (const Pictures* working = mPictures.end(); working != first; ) { |
| --working; |
| const SkPicture* pict = working->mPicture; |
| const SkRegion& area = working->mArea; |
| const SkIRect& bounds = area.getBounds(); |
| bool localValid = false; |
| if (working->mUnsplit.isEmpty()) |
| LOGD("%s working->mUnsplit.isEmpty()", funct); |
| else if (working->mUnsplit.contains(bounds) == false) |
| LOGD("%s working->mUnsplit.contains(bounds) == false", funct); |
| else if (working->mElapsed >= 1000) |
| LOGD("%s working->mElapsed >= 1000", funct); |
| else if ((working->mSplit & 0xfe) != 0) |
| LOGD("%s (working->mSplit & 0xfe) != 0", funct); |
| else if ((working->mWroteElapsed & 0xfe) != 0) |
| LOGD("%s (working->mWroteElapsed & 0xfe) != 0", funct); |
| else if (pict != NULL) { |
| int pictWidth = pict->width(); |
| int pictHeight = pict->height(); |
| if (pictWidth < bounds.width()) |
| LOGD("%s pictWidth=%d < bounds.width()=%d", funct, pictWidth, bounds.width()); |
| else if (pictHeight < bounds.height()) |
| LOGD("%s pictHeight=%d < bounds.height()=%d", funct, pictHeight, bounds.height()); |
| else if (working->mArea.isEmpty()) |
| LOGD("%s working->mArea.isEmpty()", funct); |
| else |
| localValid = true; |
| } else |
| localValid = true; |
| working->mArea.validate(); |
| if (localValid == false) { |
| if (all.contains(area) == true) |
| LOGD("%s all.contains(area) == true", funct); |
| else |
| localValid = true; |
| } |
| valid &= localValid; |
| all.op(area, SkRegion::kUnion_Op); |
| } |
| const SkIRect& allBounds = all.getBounds(); |
| if (valid) { |
| valid = false; |
| if (allBounds.width() != mWidth) |
| LOGD("%s allBounds.width()=%d != mWidth=%d", funct, allBounds.width(), mWidth); |
| else if (allBounds.height() != mHeight) |
| LOGD("%s allBounds.height()=%d != mHeight=%d", funct, allBounds.height(), mHeight); |
| else |
| valid = true; |
| } |
| while (valid == false) |
| ; |
| #endif |
| return valid; |
| #endif // FAST_PICTURESET |
| } |
| |
| } /* namespace android */ |
