| Index: src/core/SkPictureData.cpp
|
| diff --git a/src/core/SkPictureData.cpp b/src/core/SkPictureData.cpp
|
| index d121a302ba87977c4b1d4228fb20e59ee0a06d19..15ba45d7d6c4c75ef171802a8ae79c1252115a5d 100644
|
| --- a/src/core/SkPictureData.cpp
|
| +++ b/src/core/SkPictureData.cpp
|
| @@ -28,33 +28,6 @@ template <typename T> int SafeCount(const T* obj) {
|
| */
|
| #define SPEW_CLIP_SKIPPINGx
|
|
|
| -SkPictureData::PlaybackReplacements::ReplacementInfo*
|
| -SkPictureData::PlaybackReplacements::push() {
|
| - SkDEBUGCODE(this->validate());
|
| - return fReplacements.push();
|
| -}
|
| -
|
| -void SkPictureData::PlaybackReplacements::freeAll() {
|
| - for (int i = 0; i < fReplacements.count(); ++i) {
|
| - SkDELETE(fReplacements[i].fBM);
|
| - }
|
| - fReplacements.reset();
|
| -}
|
| -
|
| -#ifdef SK_DEBUG
|
| -void SkPictureData::PlaybackReplacements::validate() const {
|
| - // Check that the ranges are monotonically increasing and non-overlapping
|
| - if (fReplacements.count() > 0) {
|
| - SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);
|
| -
|
| - for (int i = 1; i < fReplacements.count(); ++i) {
|
| - SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
|
| - SkASSERT(fReplacements[i-1].fStop < fReplacements[i].fStart);
|
| - }
|
| - }
|
| -}
|
| -#endif
|
| -
|
| SkPictureData::SkPictureData(const SkPictInfo& info)
|
| : fInfo(info) {
|
| this->init();
|
| @@ -260,12 +233,6 @@ void SkPictureData::init() {
|
| fFactoryPlayback = NULL;
|
| fBoundingHierarchy = NULL;
|
| fStateTree = NULL;
|
| - fCachedActiveOps = NULL;
|
| - fCurOffset = 0;
|
| - fUseBBH = true;
|
| - fStart = 0;
|
| - fStop = 0;
|
| - fReplacements = NULL;
|
| }
|
|
|
| SkPictureData::~SkPictureData() {
|
| @@ -276,8 +243,6 @@ SkPictureData::~SkPictureData() {
|
| SkSafeUnref(fBoundingHierarchy);
|
| SkSafeUnref(fStateTree);
|
|
|
| - SkDELETE(fCachedActiveOps);
|
| -
|
| for (int i = 0; i < fPictureCount; i++) {
|
| fPictureRefs[i]->unref();
|
| }
|
| @@ -475,9 +440,9 @@ static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) {
|
| }
|
|
|
| bool SkPictureData::parseStreamTag(SkStream* stream,
|
| - uint32_t tag,
|
| - uint32_t size,
|
| - SkPicture::InstallPixelRefProc proc) {
|
| + uint32_t tag,
|
| + uint32_t size,
|
| + SkPicture::InstallPixelRefProc proc) {
|
| /*
|
| * By the time we encounter BUFFER_SIZE_TAG, we need to have already seen
|
| * its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
|
| @@ -587,7 +552,7 @@ bool SkPictureData::parseStreamTag(SkStream* stream,
|
| }
|
|
|
| bool SkPictureData::parseBufferTag(SkReadBuffer& buffer,
|
| - uint32_t tag, uint32_t size) {
|
| + uint32_t tag, uint32_t size) {
|
| switch (tag) {
|
| case SK_PICT_BITMAP_BUFFER_TAG: {
|
| const int count = SkToInt(size);
|
| @@ -725,656 +690,33 @@ struct SkipClipRec {
|
| };
|
| #endif
|
|
|
| -#ifdef SK_DEVELOPER
|
| -bool SkPictureData::preDraw(int opIndex, int type) {
|
| - return false;
|
| -}
|
| -
|
| -void SkPictureData::postDraw(int opIndex) {
|
| -}
|
| -#endif
|
| -
|
| -/*
|
| - * Read the next op code and chunk size from 'reader'. The returned size
|
| - * is the entire size of the chunk (including the opcode). Thus, the
|
| - * offset just prior to calling read_op_and_size + 'size' is the offset
|
| - * to the next chunk's op code. This also means that the size of a chunk
|
| - * with no arguments (just an opcode) will be 4.
|
| - */
|
| -static DrawType read_op_and_size(SkReader32* reader, uint32_t* size) {
|
| - uint32_t temp = reader->readInt();
|
| - uint32_t op;
|
| - if (((uint8_t) temp) == temp) {
|
| - // old skp file - no size information
|
| - op = temp;
|
| - *size = 0;
|
| - } else {
|
| - UNPACK_8_24(temp, op, *size);
|
| - if (MASK_24 == *size) {
|
| - *size = reader->readInt();
|
| - }
|
| - }
|
| - return (DrawType) op;
|
| -}
|
| -
|
| -uint32_t SkPictureData::CachedOperationList::offset(int index) const {
|
| +uint32_t SkPictureData::OperationList::offset(int index) const {
|
| SkASSERT(index < fOps.count());
|
| return ((SkPictureStateTree::Draw*)fOps[index])->fOffset;
|
| }
|
|
|
| -const SkMatrix& SkPictureData::CachedOperationList::matrix(int index) const {
|
| +const SkMatrix& SkPictureData::OperationList::matrix(int index) const {
|
| SkASSERT(index < fOps.count());
|
| return *((SkPictureStateTree::Draw*)fOps[index])->fMatrix;
|
| }
|
|
|
| -const SkPicture::OperationList& SkPictureData::getActiveOps(const SkIRect& query) {
|
| +const SkPicture::OperationList* SkPictureData::getActiveOps(const SkIRect& query) const {
|
| if (NULL == fStateTree || NULL == fBoundingHierarchy) {
|
| - return SkPicture::OperationList::InvalidList();
|
| - }
|
| -
|
| - if (NULL == fCachedActiveOps) {
|
| - fCachedActiveOps = SkNEW(CachedOperationList);
|
| - }
|
| -
|
| - if (query == fCachedActiveOps->fCacheQueryRect) {
|
| - return *fCachedActiveOps;
|
| + return NULL;
|
| }
|
|
|
| - fCachedActiveOps->fOps.rewind();
|
| + OperationList* activeOps = SkNEW(OperationList);
|
|
|
| - fBoundingHierarchy->search(query, &(fCachedActiveOps->fOps));
|
| - if (0 != fCachedActiveOps->fOps.count()) {
|
| + fBoundingHierarchy->search(query, &(activeOps->fOps));
|
| + if (0 != activeOps->fOps.count()) {
|
| SkTQSort<SkPictureStateTree::Draw>(
|
| - reinterpret_cast<SkPictureStateTree::Draw**>(fCachedActiveOps->fOps.begin()),
|
| - reinterpret_cast<SkPictureStateTree::Draw**>(fCachedActiveOps->fOps.end()-1));
|
| - }
|
| -
|
| - fCachedActiveOps->fCacheQueryRect = query;
|
| - return *fCachedActiveOps;
|
| -}
|
| -
|
| -class SkAutoResetOpID {
|
| -public:
|
| - SkAutoResetOpID(SkPictureData* data) : fData(data) { }
|
| - ~SkAutoResetOpID() {
|
| - if (NULL != fData) {
|
| - fData->resetOpID();
|
| - }
|
| - }
|
| -
|
| -private:
|
| - SkPictureData* fData;
|
| -};
|
| -
|
| -// TODO: Replace with hash or pass in "lastLookedUp" hint
|
| -SkPictureData::PlaybackReplacements::ReplacementInfo*
|
| -SkPictureData::PlaybackReplacements::lookupByStart(size_t start) {
|
| - SkDEBUGCODE(this->validate());
|
| - for (int i = 0; i < fReplacements.count(); ++i) {
|
| - if (start == fReplacements[i].fStart) {
|
| - return &fReplacements[i];
|
| - } else if (start < fReplacements[i].fStart) {
|
| - return NULL; // the ranges are monotonically increasing and non-overlapping
|
| - }
|
| + reinterpret_cast<SkPictureStateTree::Draw**>(activeOps->fOps.begin()),
|
| + reinterpret_cast<SkPictureStateTree::Draw**>(activeOps->fOps.end()-1));
|
| }
|
|
|
| - return NULL;
|
| + return activeOps;
|
| }
|
|
|
| -void SkPictureData::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) {
|
| - SkAutoResetOpID aroi(this);
|
| - SkASSERT(0 == fCurOffset);
|
| -
|
| -#ifdef ENABLE_TIME_DRAW
|
| - SkAutoTime at("SkPicture::draw", 50);
|
| -#endif
|
| -
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull;
|
| - int opCount = 0;
|
| -#endif
|
| -
|
| -#ifdef SK_BUILD_FOR_ANDROID
|
| - SkAutoMutexAcquire autoMutex(fDrawMutex);
|
| -#endif
|
| -
|
| - // kDrawComplete will be the signal that we have reached the end of
|
| - // the command stream
|
| - static const uint32_t kDrawComplete = SK_MaxU32;
|
| -
|
| - SkReader32 reader(fOpData->bytes(), fOpData->size());
|
| - TextContainer text;
|
| - const SkTDArray<void*>* activeOps = NULL;
|
| -
|
| - // When draw limits are enabled (i.e., 0 != fStart || 0 != fStop) the state
|
| - // tree isn't used to pick and choose the draw operations
|
| - if (0 == fStart && 0 == fStop) {
|
| - if (fUseBBH && NULL != fStateTree && NULL != fBoundingHierarchy) {
|
| - SkRect clipBounds;
|
| - if (canvas.getClipBounds(&clipBounds)) {
|
| - SkIRect query;
|
| - clipBounds.roundOut(&query);
|
| -
|
| - const SkPicture::OperationList& activeOpsList = this->getActiveOps(query);
|
| - if (activeOpsList.valid()) {
|
| - if (0 == activeOpsList.numOps()) {
|
| - return; // nothing to draw
|
| - }
|
| -
|
| - // Since the opList is valid we know it is our derived class
|
| - activeOps = &((const CachedOperationList&)activeOpsList).fOps;
|
| - }
|
| - }
|
| - }
|
| - }
|
| -
|
| - SkPictureStateTree::Iterator it = (NULL == activeOps) ?
|
| - SkPictureStateTree::Iterator() :
|
| - fStateTree->getIterator(*activeOps, &canvas);
|
| -
|
| - if (0 != fStart || 0 != fStop) {
|
| - reader.setOffset(fStart);
|
| - uint32_t size;
|
| - SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
|
| - SkASSERT(SAVE_LAYER == op);
|
| - reader.setOffset(fStart+size);
|
| - }
|
| -
|
| - if (it.isValid()) {
|
| - uint32_t skipTo = it.nextDraw();
|
| - if (kDrawComplete == skipTo) {
|
| - return;
|
| - }
|
| - reader.setOffset(skipTo);
|
| - }
|
| -
|
| - // Record this, so we can concat w/ it if we encounter a setMatrix()
|
| - SkMatrix initialMatrix = canvas.getTotalMatrix();
|
| -
|
| - SkAutoCanvasRestore acr(&canvas, false);
|
| -
|
| -#ifdef SK_BUILD_FOR_ANDROID
|
| - fAbortCurrentPlayback = false;
|
| -#endif
|
| -
|
| -#ifdef SK_DEVELOPER
|
| - int opIndex = -1;
|
| -#endif
|
| -
|
| - while (!reader.eof()) {
|
| - if (callback && callback->abortDrawing()) {
|
| - return;
|
| - }
|
| -#ifdef SK_BUILD_FOR_ANDROID
|
| - if (fAbortCurrentPlayback) {
|
| - return;
|
| - }
|
| -#endif
|
| - if (0 != fStart || 0 != fStop) {
|
| - size_t offset = reader.offset() ;
|
| - if (offset >= fStop) {
|
| - uint32_t size;
|
| - SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
|
| - SkASSERT(RESTORE == op);
|
| - return;
|
| - }
|
| - }
|
| -
|
| - if (NULL != fReplacements) {
|
| - // Potentially replace a block of operations with a single drawBitmap call
|
| - SkPictureData::PlaybackReplacements::ReplacementInfo* temp =
|
| - fReplacements->lookupByStart(reader.offset());
|
| - if (NULL != temp) {
|
| - SkASSERT(NULL != temp->fBM);
|
| - SkASSERT(NULL != temp->fPaint);
|
| - canvas.save();
|
| - canvas.setMatrix(initialMatrix);
|
| - SkRect src = SkRect::Make(temp->fSrcRect);
|
| - SkRect dst = SkRect::MakeXYWH(temp->fPos.fX, temp->fPos.fY,
|
| - temp->fSrcRect.width(),
|
| - temp->fSrcRect.height());
|
| - canvas.drawBitmapRectToRect(*temp->fBM, &src, dst, temp->fPaint);
|
| - canvas.restore();
|
| -
|
| - if (it.isValid()) {
|
| - // This save is needed since the BBH will automatically issue
|
| - // a restore to balanced the saveLayer we're skipping
|
| - canvas.save();
|
| -
|
| - // At this point we know that the PictureStateTree was aiming
|
| - // for some draw op within temp's saveLayer (although potentially
|
| - // in a separate saveLayer nested inside it).
|
| - // We need to skip all the operations inside temp's range
|
| - // along with all the associated state changes but update
|
| - // the state tree to the first operation outside temp's range.
|
| -
|
| - uint32_t skipTo;
|
| - do {
|
| - skipTo = it.nextDraw();
|
| - if (kDrawComplete == skipTo) {
|
| - break;
|
| - }
|
| -
|
| - if (skipTo <= temp->fStop) {
|
| - reader.setOffset(skipTo);
|
| - uint32_t size;
|
| - DrawType op = read_op_and_size(&reader, &size);
|
| - // Since we are relying on the normal SkPictureStateTree
|
| - // playback we need to convert any nested saveLayer calls
|
| - // it may issue into saves (so that all its internal
|
| - // restores will be balanced).
|
| - if (SAVE_LAYER == op) {
|
| - canvas.save();
|
| - }
|
| - }
|
| - } while (skipTo <= temp->fStop);
|
| -
|
| - if (kDrawComplete == skipTo) {
|
| - break;
|
| - }
|
| -
|
| - reader.setOffset(skipTo);
|
| - } else {
|
| - reader.setOffset(temp->fStop);
|
| - uint32_t size;
|
| - SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
|
| - SkASSERT(RESTORE == op);
|
| - }
|
| - continue;
|
| - }
|
| - }
|
| -
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - opCount++;
|
| -#endif
|
| -
|
| - fCurOffset = reader.offset();
|
| - uint32_t size;
|
| - DrawType op = read_op_and_size(&reader, &size);
|
| - size_t skipTo = 0;
|
| - if (NOOP == op) {
|
| - // NOOPs are to be ignored - do not propagate them any further
|
| - skipTo = fCurOffset + size;
|
| -#ifdef SK_DEVELOPER
|
| - } else {
|
| - opIndex++;
|
| - if (this->preDraw(opIndex, op)) {
|
| - skipTo = fCurOffset + size;
|
| - }
|
| -#endif
|
| - }
|
| -
|
| - if (0 != skipTo) {
|
| - if (it.isValid()) {
|
| - // If using a bounding box hierarchy, advance the state tree
|
| - // iterator until at or after skipTo
|
| - uint32_t adjustedSkipTo;
|
| - do {
|
| - adjustedSkipTo = it.nextDraw();
|
| - } while (adjustedSkipTo < skipTo);
|
| - skipTo = adjustedSkipTo;
|
| - }
|
| - if (kDrawComplete == skipTo) {
|
| - break;
|
| - }
|
| - reader.setOffset(skipTo);
|
| - continue;
|
| - }
|
| -
|
| - switch (op) {
|
| - case CLIP_PATH: {
|
| - const SkPath& path = getPath(reader);
|
| - uint32_t packed = reader.readInt();
|
| - SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
|
| - bool doAA = ClipParams_unpackDoAA(packed);
|
| - size_t offsetToRestore = reader.readInt();
|
| - SkASSERT(!offsetToRestore || \
|
| - offsetToRestore >= reader.offset());
|
| - canvas.clipPath(path, regionOp, doAA);
|
| - if (canvas.isClipEmpty() && offsetToRestore) {
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - skipPath.recordSkip(offsetToRestore - reader.offset());
|
| -#endif
|
| - reader.setOffset(offsetToRestore);
|
| - }
|
| - } break;
|
| - case CLIP_REGION: {
|
| - SkRegion region;
|
| - this->getRegion(reader, ®ion);
|
| - uint32_t packed = reader.readInt();
|
| - SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
|
| - size_t offsetToRestore = reader.readInt();
|
| - SkASSERT(!offsetToRestore || \
|
| - offsetToRestore >= reader.offset());
|
| - canvas.clipRegion(region, regionOp);
|
| - if (canvas.isClipEmpty() && offsetToRestore) {
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - skipRegion.recordSkip(offsetToRestore - reader.offset());
|
| -#endif
|
| - reader.setOffset(offsetToRestore);
|
| - }
|
| - } break;
|
| - case CLIP_RECT: {
|
| - const SkRect& rect = reader.skipT<SkRect>();
|
| - uint32_t packed = reader.readInt();
|
| - SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
|
| - bool doAA = ClipParams_unpackDoAA(packed);
|
| - size_t offsetToRestore = reader.readInt();
|
| - SkASSERT(!offsetToRestore || \
|
| - offsetToRestore >= reader.offset());
|
| - canvas.clipRect(rect, regionOp, doAA);
|
| - if (canvas.isClipEmpty() && offsetToRestore) {
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - skipRect.recordSkip(offsetToRestore - reader.offset());
|
| -#endif
|
| - reader.setOffset(offsetToRestore);
|
| - }
|
| - } break;
|
| - case CLIP_RRECT: {
|
| - SkRRect rrect;
|
| - reader.readRRect(&rrect);
|
| - uint32_t packed = reader.readInt();
|
| - SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
|
| - bool doAA = ClipParams_unpackDoAA(packed);
|
| - size_t offsetToRestore = reader.readInt();
|
| - SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
|
| - canvas.clipRRect(rrect, regionOp, doAA);
|
| - if (canvas.isClipEmpty() && offsetToRestore) {
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - skipRRect.recordSkip(offsetToRestore - reader.offset());
|
| -#endif
|
| - reader.setOffset(offsetToRestore);
|
| - }
|
| - } break;
|
| - case PUSH_CULL: {
|
| - const SkRect& cullRect = reader.skipT<SkRect>();
|
| - size_t offsetToRestore = reader.readInt();
|
| - if (offsetToRestore && canvas.quickReject(cullRect)) {
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - skipCull.recordSkip(offsetToRestore - reader.offset());
|
| -#endif
|
| - reader.setOffset(offsetToRestore);
|
| - } else {
|
| - canvas.pushCull(cullRect);
|
| - }
|
| - } break;
|
| - case POP_CULL:
|
| - canvas.popCull();
|
| - break;
|
| - case CONCAT: {
|
| - SkMatrix matrix;
|
| - this->getMatrix(reader, &matrix);
|
| - canvas.concat(matrix);
|
| - break;
|
| - }
|
| - case DRAW_BITMAP: {
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - const SkBitmap& bitmap = this->getBitmap(reader);
|
| - const SkPoint& loc = reader.skipT<SkPoint>();
|
| - canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint);
|
| - } break;
|
| - case DRAW_BITMAP_RECT_TO_RECT: {
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - const SkBitmap& bitmap = this->getBitmap(reader);
|
| - const SkRect* src = this->getRectPtr(reader); // may be null
|
| - const SkRect& dst = reader.skipT<SkRect>(); // required
|
| - SkCanvas::DrawBitmapRectFlags flags;
|
| - flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt();
|
| - canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags);
|
| - } break;
|
| - case DRAW_BITMAP_MATRIX: {
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - const SkBitmap& bitmap = this->getBitmap(reader);
|
| - SkMatrix matrix;
|
| - this->getMatrix(reader, &matrix);
|
| - canvas.drawBitmapMatrix(bitmap, matrix, paint);
|
| - } break;
|
| - case DRAW_BITMAP_NINE: {
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - const SkBitmap& bitmap = this->getBitmap(reader);
|
| - const SkIRect& src = reader.skipT<SkIRect>();
|
| - const SkRect& dst = reader.skipT<SkRect>();
|
| - canvas.drawBitmapNine(bitmap, src, dst, paint);
|
| - } break;
|
| - case DRAW_CLEAR:
|
| - canvas.clear(reader.readInt());
|
| - break;
|
| - case DRAW_DATA: {
|
| - size_t length = reader.readInt();
|
| - canvas.drawData(reader.skip(length), length);
|
| - // skip handles padding the read out to a multiple of 4
|
| - } break;
|
| - case DRAW_DRRECT: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - SkRRect outer, inner;
|
| - reader.readRRect(&outer);
|
| - reader.readRRect(&inner);
|
| - canvas.drawDRRect(outer, inner, paint);
|
| - } break;
|
| - case BEGIN_COMMENT_GROUP: {
|
| - const char* desc = reader.readString();
|
| - canvas.beginCommentGroup(desc);
|
| - } break;
|
| - case COMMENT: {
|
| - const char* kywd = reader.readString();
|
| - const char* value = reader.readString();
|
| - canvas.addComment(kywd, value);
|
| - } break;
|
| - case END_COMMENT_GROUP: {
|
| - canvas.endCommentGroup();
|
| - } break;
|
| - case DRAW_OVAL: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - canvas.drawOval(reader.skipT<SkRect>(), paint);
|
| - } break;
|
| - case DRAW_PAINT:
|
| - canvas.drawPaint(*this->getPaint(reader));
|
| - break;
|
| - case DRAW_PATH: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - canvas.drawPath(getPath(reader), paint);
|
| - } break;
|
| - case DRAW_PICTURE:
|
| - canvas.drawPicture(this->getPicture(reader));
|
| - break;
|
| - case DRAW_POINTS: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - SkCanvas::PointMode mode = (SkCanvas::PointMode)reader.readInt();
|
| - size_t count = reader.readInt();
|
| - const SkPoint* pts = (const SkPoint*)reader.skip(sizeof(SkPoint) * count);
|
| - canvas.drawPoints(mode, count, pts, paint);
|
| - } break;
|
| - case DRAW_POS_TEXT: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - getText(reader, &text);
|
| - size_t points = reader.readInt();
|
| - const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
|
| - canvas.drawPosText(text.text(), text.length(), pos, paint);
|
| - } break;
|
| - case DRAW_POS_TEXT_TOP_BOTTOM: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - getText(reader, &text);
|
| - size_t points = reader.readInt();
|
| - const SkPoint* pos = (const SkPoint*)reader.skip(points * sizeof(SkPoint));
|
| - const SkScalar top = reader.readScalar();
|
| - const SkScalar bottom = reader.readScalar();
|
| - if (!canvas.quickRejectY(top, bottom)) {
|
| - canvas.drawPosText(text.text(), text.length(), pos, paint);
|
| - }
|
| - } break;
|
| - case DRAW_POS_TEXT_H: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - getText(reader, &text);
|
| - size_t xCount = reader.readInt();
|
| - const SkScalar constY = reader.readScalar();
|
| - const SkScalar* xpos = (const SkScalar*)reader.skip(xCount * sizeof(SkScalar));
|
| - canvas.drawPosTextH(text.text(), text.length(), xpos, constY,
|
| - paint);
|
| - } break;
|
| - case DRAW_POS_TEXT_H_TOP_BOTTOM: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - getText(reader, &text);
|
| - size_t xCount = reader.readInt();
|
| - const SkScalar* xpos = (const SkScalar*)reader.skip((3 + xCount) * sizeof(SkScalar));
|
| - const SkScalar top = *xpos++;
|
| - const SkScalar bottom = *xpos++;
|
| - const SkScalar constY = *xpos++;
|
| - if (!canvas.quickRejectY(top, bottom)) {
|
| - canvas.drawPosTextH(text.text(), text.length(), xpos,
|
| - constY, paint);
|
| - }
|
| - } break;
|
| - case DRAW_RECT: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - canvas.drawRect(reader.skipT<SkRect>(), paint);
|
| - } break;
|
| - case DRAW_RRECT: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - SkRRect rrect;
|
| - reader.readRRect(&rrect);
|
| - canvas.drawRRect(rrect, paint);
|
| - } break;
|
| - case DRAW_SPRITE: {
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - const SkBitmap& bitmap = this->getBitmap(reader);
|
| - int left = reader.readInt();
|
| - int top = reader.readInt();
|
| - canvas.drawSprite(bitmap, left, top, paint);
|
| - } break;
|
| - case DRAW_TEXT: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - this->getText(reader, &text);
|
| - SkScalar x = reader.readScalar();
|
| - SkScalar y = reader.readScalar();
|
| - canvas.drawText(text.text(), text.length(), x, y, paint);
|
| - } break;
|
| - case DRAW_TEXT_TOP_BOTTOM: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - this->getText(reader, &text);
|
| - const SkScalar* ptr = (const SkScalar*)reader.skip(4 * sizeof(SkScalar));
|
| - // ptr[0] == x
|
| - // ptr[1] == y
|
| - // ptr[2] == top
|
| - // ptr[3] == bottom
|
| - if (!canvas.quickRejectY(ptr[2], ptr[3])) {
|
| - canvas.drawText(text.text(), text.length(), ptr[0], ptr[1],
|
| - paint);
|
| - }
|
| - } break;
|
| - case DRAW_TEXT_ON_PATH: {
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - getText(reader, &text);
|
| - const SkPath& path = this->getPath(reader);
|
| - SkMatrix matrix;
|
| - this->getMatrix(reader, &matrix);
|
| - canvas.drawTextOnPath(text.text(), text.length(), path, &matrix, paint);
|
| - } break;
|
| - case DRAW_VERTICES: {
|
| - SkAutoTUnref<SkXfermode> xfer;
|
| - const SkPaint& paint = *this->getPaint(reader);
|
| - DrawVertexFlags flags = (DrawVertexFlags)reader.readInt();
|
| - SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt();
|
| - int vCount = reader.readInt();
|
| - const SkPoint* verts = (const SkPoint*)reader.skip(
|
| - vCount * sizeof(SkPoint));
|
| - const SkPoint* texs = NULL;
|
| - const SkColor* colors = NULL;
|
| - const uint16_t* indices = NULL;
|
| - int iCount = 0;
|
| - if (flags & DRAW_VERTICES_HAS_TEXS) {
|
| - texs = (const SkPoint*)reader.skip(
|
| - vCount * sizeof(SkPoint));
|
| - }
|
| - if (flags & DRAW_VERTICES_HAS_COLORS) {
|
| - colors = (const SkColor*)reader.skip(
|
| - vCount * sizeof(SkColor));
|
| - }
|
| - if (flags & DRAW_VERTICES_HAS_INDICES) {
|
| - iCount = reader.readInt();
|
| - indices = (const uint16_t*)reader.skip(
|
| - iCount * sizeof(uint16_t));
|
| - }
|
| - if (flags & DRAW_VERTICES_HAS_XFER) {
|
| - int mode = reader.readInt();
|
| - if (mode < 0 || mode > SkXfermode::kLastMode) {
|
| - mode = SkXfermode::kModulate_Mode;
|
| - }
|
| - xfer.reset(SkXfermode::Create((SkXfermode::Mode)mode));
|
| - }
|
| - canvas.drawVertices(vmode, vCount, verts, texs, colors, xfer,
|
| - indices, iCount, paint);
|
| - } break;
|
| - case RESTORE:
|
| - canvas.restore();
|
| - break;
|
| - case ROTATE:
|
| - canvas.rotate(reader.readScalar());
|
| - break;
|
| - case SAVE:
|
| - // SKPs with version < 29 also store a SaveFlags param.
|
| - if (size > 4) {
|
| - SkASSERT(8 == size);
|
| - reader.readInt();
|
| - }
|
| - canvas.save();
|
| - break;
|
| - case SAVE_LAYER: {
|
| - const SkRect* boundsPtr = this->getRectPtr(reader);
|
| - const SkPaint* paint = this->getPaint(reader);
|
| - canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt());
|
| - } break;
|
| - case SCALE: {
|
| - SkScalar sx = reader.readScalar();
|
| - SkScalar sy = reader.readScalar();
|
| - canvas.scale(sx, sy);
|
| - } break;
|
| - case SET_MATRIX: {
|
| - SkMatrix matrix;
|
| - this->getMatrix(reader, &matrix);
|
| - matrix.postConcat(initialMatrix);
|
| - canvas.setMatrix(matrix);
|
| - } break;
|
| - case SKEW: {
|
| - SkScalar sx = reader.readScalar();
|
| - SkScalar sy = reader.readScalar();
|
| - canvas.skew(sx, sy);
|
| - } break;
|
| - case TRANSLATE: {
|
| - SkScalar dx = reader.readScalar();
|
| - SkScalar dy = reader.readScalar();
|
| - canvas.translate(dx, dy);
|
| - } break;
|
| - default:
|
| - SkASSERT(0);
|
| - }
|
| -
|
| -#ifdef SK_DEVELOPER
|
| - this->postDraw(opIndex);
|
| -#endif
|
| -
|
| - if (it.isValid()) {
|
| - uint32_t skipTo = it.nextDraw();
|
| - if (kDrawComplete == skipTo) {
|
| - break;
|
| - }
|
| - reader.setOffset(skipTo);
|
| - }
|
| - }
|
| -
|
| -#ifdef SPEW_CLIP_SKIPPING
|
| - {
|
| - size_t size = skipRect.fSize + skipRRect.fSize + skipPath.fSize + skipRegion.fSize +
|
| - skipCull.fSize;
|
| - SkDebugf("--- Clip skips %d%% rect:%d rrect:%d path:%d rgn:%d cull:%d\n",
|
| - size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount,
|
| - skipPath.fCount, skipRegion.fCount, skipCull.fCount);
|
| - SkDebugf("--- Total ops: %d\n", opCount);
|
| - }
|
| -#endif
|
| -// this->dumpSize();
|
| -}
|
| -
|
| -
|
| #if SK_SUPPORT_GPU
|
| bool SkPictureData::suitableForGpuRasterization(GrContext* context, const char **reason,
|
| int sampleCount) const {
|
| @@ -1750,7 +1092,6 @@ void SkPictureData::dumpText(char** bufferPtrPtr, char* buffer) {
|
| void SkPictureData::dumpStream() {
|
| SkDebugf("RecordStream stream = {\n");
|
| DrawType drawType;
|
| - TextContainer text;
|
| fReadStream.rewind();
|
| char buffer[DUMP_BUFFER_SIZE], * bufferPtr;
|
| while (fReadStream.read(&drawType, sizeof(drawType))) {
|
|
|