// A lot of basic types get stored as a uint32_t: bools, ints, paint indices, etc.
static int const kUInt32Size = 4;
-static const int kSaveLayerNoBoundsSize = 4 * kUInt32Size;
-static const int kSaveLayerWithBoundsSize = 4 * kUInt32Size + sizeof(SkRect);
-
SkPictureRecord::SkPictureRecord(uint32_t flags, SkDevice* device) :
INHERITED(device),
fBoundingHierarchy(NULL),
///////////////////////////////////////////////////////////////////////////////
-// Return the offset of the paint inside a given op's byte stream. A zero
-// return value means there is no paint (and you really shouldn't be calling
-// this method)
-static inline uint32_t getPaintOffset(DrawType op, uint32_t opSize) {
- // These offsets are where the paint would be if the op size doesn't overflow
- static const uint8_t gPaintOffsets[LAST_DRAWTYPE_ENUM + 1] = {
- 0, // UNUSED - no paint
- 0, // CLIP_PATH - no paint
- 0, // CLIP_REGION - no paint
- 0, // CLIP_RECT - no paint
- 0, // CLIP_RRECT - no paint
- 0, // CONCAT - no paint
- 1, // DRAW_BITMAP - right after op code
- 1, // DRAW_BITMAP_MATRIX - right after op code
- 1, // DRAW_BITMAP_NINE - right after op code
- 1, // DRAW_BITMAP_RECT_TO_RECT - right after op code
- 0, // DRAW_CLEAR - no paint
- 0, // DRAW_DATA - no paint
- 1, // DRAW_OVAL - right after op code
- 1, // DRAW_PAINT - right after op code
- 1, // DRAW_PATH - right after op code
- 0, // DRAW_PICTURE - no paint
- 1, // DRAW_POINTS - right after op code
- 1, // DRAW_POS_TEXT - right after op code
- 1, // DRAW_POS_TEXT_TOP_BOTTOM - right after op code
- 1, // DRAW_POS_TEXT_H - right after op code
- 1, // DRAW_POS_TEXT_H_TOP_BOTTOM - right after op code
- 1, // DRAW_RECT - right after op code
- 1, // DRAW_RRECT - right after op code
- 1, // DRAW_SPRITE - right after op code
- 1, // DRAW_TEXT - right after op code
- 1, // DRAW_TEXT_ON_PATH - right after op code
- 1, // DRAW_TEXT_TOP_BOTTOM - right after op code
- 1, // DRAW_VERTICES - right after op code
- 0, // RESTORE - no paint
- 0, // ROTATE - no paint
- 0, // SAVE - no paint
- 0, // SAVE_LAYER - see below - this paint's location varies
- 0, // SCALE - no paint
- 0, // SET_MATRIX - no paint
- 0, // SKEW - no paint
- 0, // TRANSLATE - no paint
- 0, // NOOP - no paint
- };
-
- SkASSERT(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1);
- SkASSERT((unsigned)op <= (unsigned)LAST_DRAWTYPE_ENUM);
-
- int overflow = 0;
- if (0 != (opSize & ~MASK_24) || opSize == MASK_24) {
- // This op's size overflows so an extra uint32_t will be written
- // after the op code
- overflow = sizeof(uint32_t);
- }
-
- if (SAVE_LAYER == op) {
- static const int kSaveLayerNoBoundsPaintOffset = 2 * kUInt32Size;
- static const int kSaveLayerWithBoundsPaintOffset = 2 * kUInt32Size + sizeof(SkRect);
-
- if (kSaveLayerNoBoundsSize == opSize) {
- return kSaveLayerNoBoundsPaintOffset + overflow;
- } else {
- SkASSERT(kSaveLayerWithBoundsSize == opSize);
- return kSaveLayerWithBoundsPaintOffset + overflow;
- }
- }
-
- SkASSERT(0 != gPaintOffsets[op]); // really shouldn't be calling this method
- return gPaintOffsets[op] * sizeof(uint32_t) + overflow;
-}
-
SkDevice* SkPictureRecord::setDevice(SkDevice* device) {
SkASSERT(!"eeek, don't try to change the device on a recording canvas");
return this->INHERITED::setDevice(device);
// + paint index + flags
size += 2 * kUInt32Size;
- SkASSERT(kSaveLayerNoBoundsSize == size || kSaveLayerWithBoundsSize == size);
-
uint32_t initialOffset = this->addDraw(SAVE_LAYER, &size);
addRectPtr(bounds);
- SkASSERT(initialOffset+getPaintOffset(SAVE_LAYER, size) == fWriter.size());
addPaintPtr(paint);
addInt(flags);
static int gCollapseCount, gCollapseCalls;
#endif
-// Is the supplied paint simply a color?
-static bool is_simple(const SkPaint& p) {
- intptr_t orAccum = (intptr_t)p.getPathEffect() |
- (intptr_t)p.getShader() |
- (intptr_t)p.getXfermode() |
- (intptr_t)p.getMaskFilter() |
- (intptr_t)p.getColorFilter() |
- (intptr_t)p.getRasterizer() |
- (intptr_t)p.getLooper() |
- (intptr_t)p.getImageFilter();
- return 0 == orAccum;
-}
-
-/*
- * Restore has just been called (but not recorded), look back at the
- * matching save* and see if we are in the configuration:
- * SAVE_LAYER
- * DRAW_BITMAP|DRAW_BITMAP_MATRIX|DRAW_BITMAP_NINE|DRAW_BITMAP_RECT_TO_RECT
- * RESTORE
- * where the saveLayer's color can be moved into the drawBitmap*'s paint
- */
-static bool remove_save_layer1(SkWriter32* writer, int32_t offset,
- SkPaintDictionary* paintDict) {
-
- int32_t restoreOffset = (int32_t)writer->size();
-
- // back up to the save block
- // TODO: add a stack to track save*/restore offsets rather than searching backwards
- while (offset > 0) {
- offset = *writer->peek32(offset);
- }
-
- // now offset points to a save
- int32_t saveLayerOffset = -offset;
- uint32_t saveLayerSize;
- DrawType op = peek_op_and_size(writer, saveLayerOffset, &saveLayerSize);
- if (SAVE_LAYER != op) {
- SkASSERT(SAVE == op);
- return false; // not a match
- }
-
- // step forward one - check if it is a DRAW_BITMAP*
- int32_t dbmOffset = saveLayerOffset + saveLayerSize;
- if (dbmOffset >= restoreOffset) {
- // Just a saveLayer and a restore? Remove it.
- writer->rewindToOffset(saveLayerOffset);
- return true;
- }
-
- uint32_t dbmSize;
- op = peek_op_and_size(writer, dbmOffset, &dbmSize);
- if (DRAW_BITMAP != op && DRAW_BITMAP_MATRIX != op &&
- DRAW_BITMAP_NINE != op && DRAW_BITMAP_RECT_TO_RECT != op) {
- return false; // not a match
- }
-
- offset = dbmOffset + dbmSize;
- if (offset < restoreOffset) {
- return false; // something else between the dbm* and the restore
- }
-
- uint32_t dbmPaintOffset = getPaintOffset(op, dbmSize);
- uint32_t slPaintOffset = getPaintOffset(SAVE_LAYER, saveLayerSize);
-
- // we have a match, now we need to get the paints involved
- int dbmPaintId = *((int32_t*)writer->peek32(dbmOffset+dbmPaintOffset));
- int saveLayerPaintId = *((int32_t*)writer->peek32(saveLayerOffset+slPaintOffset));
-
- if (0 == saveLayerPaintId) {
- // In this case the saveLayer/restore isn't needed at all - just kill the saveLayer
- // and signal the caller (by returning true) to not add the RESTORE op
- uint32_t* ptr = writer->peek32(saveLayerOffset);
- *ptr = (*ptr & MASK_24) | (NOOP << 24);
- return true;
- }
-
- if (0 == dbmPaintId) {
- // In this case just make the DBM* use the saveLayer's paint, kill the saveLayer
- // and signal the caller (by returning true) to not add the RESTORE op
- uint32_t* ptr = writer->peek32(saveLayerOffset);
- *ptr = (*ptr & MASK_24) | (NOOP << 24);
- ptr = writer->peek32(dbmOffset+dbmPaintOffset);
- SkASSERT(0 == *ptr);
- *ptr = saveLayerPaintId;
- return true;
- }
-
- SkAutoTDelete<SkPaint> saveLayerPaint(paintDict->unflatten(saveLayerPaintId));
- if (NULL == saveLayerPaint.get() || !is_simple(*saveLayerPaint)) {
- return false;
- }
-
- // For this optimization we only fold the saveLayer and drawBitmapRect
- // together if the saveLayer's draw is simple (i.e., no fancy effects) and
- // and the only difference in the colors is that the saveLayer's can have
- // an alpha while the drawBitmapRect's is opaque.
- // TODO: it should be possible to fold them together even if they both
- // have different non-255 alphas
- SkColor layerColor = saveLayerPaint->getColor() | 0xFF000000; // force opaque
-
- SkAutoTDelete<SkPaint> dbmPaint(paintDict->unflatten(dbmPaintId));
- if (NULL == dbmPaint.get() || dbmPaint->getColor() != layerColor) {
- return false;
- }
-
- SkColor newColor = SkColorSetA(dbmPaint->getColor(),
- SkColorGetA(saveLayerPaint->getColor()));
- dbmPaint->setColor(newColor);
-
- const SkFlatData* data = paintDict->findAndReturnFlat(*dbmPaint);
- if (NULL == data) {
- return false;
- }
-
- // kill the saveLayer and alter the DBMR2R's paint to be the modified one
- uint32_t* ptr = writer->peek32(saveLayerOffset);
- *ptr = (*ptr & MASK_24) | (NOOP << 24);
- ptr = writer->peek32(dbmOffset+dbmPaintOffset);
- *ptr = data->index();
- return true;
-}
-
-
/*
- * Restore has just been called (but not recorded), so look back at the
+ * Restore has just been called (but not recoreded), so look back at the
* matching save(), and see if we can eliminate the pair of them, due to no
* intervening matrix/clip calls.
*
}
uint32_t initialOffset, size;
- if (!collapseSaveClipRestore(&fWriter, fRestoreOffsetStack.top()) &&
- !remove_save_layer1(&fWriter, fRestoreOffsetStack.top(), &fPaints)) {
+ if (!collapseSaveClipRestore(&fWriter, fRestoreOffsetStack.top())) {
fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.size());
// op
size = 1 * kUInt32Size;
}
}
-void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset) {
+void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(
+ uint32_t restoreOffset) {
int32_t offset = fRestoreOffsetStack.top();
while (offset > 0) {
uint32_t* peek = fWriter.peek32(offset);
// op + paint index
uint32_t size = 2 * kUInt32Size;
uint32_t initialOffset = this->addDraw(DRAW_PAINT, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_PAINT, size) == fWriter.size());
addPaint(paint);
validate(initialOffset, size);
}
// op + paint index + mode + count + point data
uint32_t size = 4 * kUInt32Size + count * sizeof(SkPoint);
uint32_t initialOffset = this->addDraw(DRAW_POINTS, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_POINTS, size) == fWriter.size());
addPaint(paint);
addInt(mode);
addInt(count);
// op + paint index + rect
uint32_t size = 2 * kUInt32Size + sizeof(oval);
uint32_t initialOffset = this->addDraw(DRAW_OVAL, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_OVAL, size) == fWriter.size());
addPaint(paint);
addRect(oval);
validate(initialOffset, size);
// op + paint index + rect
uint32_t size = 2 * kUInt32Size + sizeof(rect);
uint32_t initialOffset = this->addDraw(DRAW_RECT, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_RECT, size) == fWriter.size());
addPaint(paint);
addRect(rect);
validate(initialOffset, size);
// op + paint index + rect
size = 2 * kUInt32Size + sizeof(SkRect);
initialOffset = this->addDraw(DRAW_RECT, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_RECT, size) == fWriter.size());
addPaint(paint);
addRect(rrect.getBounds());
} else if (rrect.isOval()) {
// op + paint index + rect
size = 2 * kUInt32Size + sizeof(SkRect);
initialOffset = this->addDraw(DRAW_OVAL, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_OVAL, size) == fWriter.size());
addPaint(paint);
addRect(rrect.getBounds());
} else {
// op + paint index + rrect
size = 2 * kUInt32Size + SkRRect::kSizeInMemory;
initialOffset = this->addDraw(DRAW_RRECT, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_RRECT, size) == fWriter.size());
addPaint(paint);
addRRect(rrect);
}
// op + paint index + path index
uint32_t size = 3 * kUInt32Size;
uint32_t initialOffset = this->addDraw(DRAW_PATH, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_PATH, size) == fWriter.size());
addPaint(paint);
addPath(path);
validate(initialOffset, size);
// op + paint index + bitmap index + left + top
uint32_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
uint32_t initialOffset = this->addDraw(DRAW_BITMAP, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP, size) == fWriter.size());
addPaintPtr(paint);
addBitmap(bitmap);
addScalar(left);
size += sizeof(dst); // + rect
uint32_t initialOffset = this->addDraw(DRAW_BITMAP_RECT_TO_RECT, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_RECT_TO_RECT, size) == fWriter.size());
addPaintPtr(paint);
addBitmap(bitmap);
addRectPtr(src); // may be null
// id + paint index + bitmap index + matrix index
uint32_t size = 4 * kUInt32Size;
uint32_t initialOffset = this->addDraw(DRAW_BITMAP_MATRIX, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_MATRIX, size) == fWriter.size());
addPaintPtr(paint);
addBitmap(bitmap);
addMatrix(matrix);
// op + paint index + bitmap id + center + dst rect
uint32_t size = 3 * kUInt32Size + sizeof(center) + sizeof(dst);
uint32_t initialOffset = this->addDraw(DRAW_BITMAP_NINE, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_NINE, size) == fWriter.size());
addPaintPtr(paint);
addBitmap(bitmap);
addIRect(center);
// op + paint index + bitmap index + left + top
uint32_t size = 5 * kUInt32Size;
uint32_t initialOffset = this->addDraw(DRAW_SPRITE, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_SPRITE, size) == fWriter.size());
addPaintPtr(paint);
addBitmap(bitmap);
addInt(left);
size += 2 * sizeof(SkScalar); // + top & bottom
}
- DrawType op = fast ? DRAW_TEXT_TOP_BOTTOM : DRAW_TEXT;
- uint32_t initialOffset = this->addDraw(op, &size);
- SkASSERT(initialOffset+getPaintOffset(op, size) == fWriter.size());
+ uint32_t initialOffset = this->addDraw(fast ? DRAW_TEXT_TOP_BOTTOM : DRAW_TEXT, &size);
const SkFlatData* flatPaintData = addPaint(paint);
SkASSERT(flatPaintData);
addText(text, byteLength);
op = DRAW_POS_TEXT;
}
uint32_t initialOffset = this->addDraw(op, &size);
- SkASSERT(initialOffset+getPaintOffset(op, size) == fWriter.size());
const SkFlatData* flatPaintData = addPaint(paint);
SkASSERT(flatPaintData);
addText(text, byteLength);
// op + paint index + length + 'length' worth of data + path index + matrix index
uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 2 * kUInt32Size;
uint32_t initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_TEXT_ON_PATH, size) == fWriter.size());
addPaint(paint);
addText(text, byteLength);
addPath(path);
}
uint32_t initialOffset = this->addDraw(DRAW_VERTICES, &size);
- SkASSERT(initialOffset+getPaintOffset(DRAW_VERTICES, size) == fWriter.size());
addPaint(paint);
addInt(flags);
addInt(vmode);
projects / platform / upstream / libSkiaSharp.git / commitdiff