Object-based DisplayList recording
bug:8037003
Changes the DisplayList from using stream read/write commands to use an array of
objects manually allocated on a linear buffer.
Depends on frameworks/native change https://googleplex-android-review.googlesource.com/#/c/257695/ which adds LinearAllocator
Also changes drawRects to use float count instead of rect count, to be more like drawLines/drawPoints
Change-Id: Ia2e4a11acd8f0a757042a05cbc9e7563cb73ee47
diff --git a/libs/hwui/DisplayListRenderer.cpp b/libs/hwui/DisplayListRenderer.cpp
index f0c9ce4..5cb629e 100644
--- a/libs/hwui/DisplayListRenderer.cpp
+++ b/libs/hwui/DisplayListRenderer.cpp
@@ -21,6 +21,7 @@
#include <private/hwui/DrawGlInfo.h>
#include "DisplayListLogBuffer.h"
+#include "DisplayListOp.h"
#include "DisplayListRenderer.h"
#include "Caches.h"
@@ -31,53 +32,6 @@
// Display list
///////////////////////////////////////////////////////////////////////////////
-const char* DisplayList::OP_NAMES[] = {
- "Save",
- "Restore",
- "RestoreToCount",
- "SaveLayer",
- "SaveLayerAlpha",
- "Translate",
- "Rotate",
- "Scale",
- "Skew",
- "SetMatrix",
- "ConcatMatrix",
- "ClipRect",
- "ClipPath",
- "ClipRegion",
- "DrawDisplayList",
- "DrawLayer",
- "DrawBitmap",
- "DrawBitmapMatrix",
- "DrawBitmapRect",
- "DrawBitmapData",
- "DrawBitmapMesh",
- "DrawPatch",
- "DrawColor",
- "DrawRect",
- "DrawRoundRect",
- "DrawCircle",
- "DrawOval",
- "DrawArc",
- "DrawPath",
- "DrawLines",
- "DrawPoints",
- "DrawTextOnPath",
- "DrawPosText",
- "DrawText",
- "DrawRects",
- "ResetShader",
- "SetupShader",
- "ResetColorFilter",
- "SetupColorFilter",
- "ResetShadow",
- "SetupShadow",
- "ResetPaintFilter",
- "SetupPaintFilter",
- "DrawGLFunction"
-};
-
void DisplayList::outputLogBuffer(int fd) {
DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
if (logBuffer.isEmpty()) {
@@ -87,7 +41,7 @@
FILE *file = fdopen(fd, "a");
fprintf(file, "\nRecent DisplayList operations\n");
- logBuffer.outputCommands(file, OP_NAMES);
+ logBuffer.outputCommands(file);
String8 cachesLog;
Caches::getInstance().dumpMemoryUsage(cachesLog);
@@ -116,9 +70,7 @@
}
void DisplayList::clearResources() {
- sk_free((void*) mReader.base());
- mReader.setMemory(NULL, 0);
-
+ mDisplayListData = NULL;
delete mTransformMatrix;
delete mTransformCamera;
delete mTransformMatrix3D;
@@ -200,7 +152,6 @@
}
void DisplayList::initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing) {
-
if (reusing) {
// re-using display list - clear out previous allocations
clearResources();
@@ -208,16 +159,13 @@
init();
- const SkWriter32& writer = recorder.writeStream();
- if (writer.size() == 0) {
+ mDisplayListData = recorder.getDisplayListData();
+ mSize = mDisplayListData->allocator.usedSize();
+
+ if (mSize == 0) {
return;
}
- mSize = writer.size();
- void* buffer = sk_malloc_throw(mSize);
- writer.flatten(buffer);
- mReader.setMemory(buffer, mSize);
-
mFunctorCount = recorder.getFunctorCount();
Caches& caches = Caches::getInstance();
@@ -312,392 +260,17 @@
* This function is a simplified version of replay(), where we simply retrieve and log the
* display list. This function should remain in sync with the replay() function.
*/
-void DisplayList::output(OpenGLRenderer& renderer, uint32_t level) {
- TextContainer text;
-
- uint32_t count = (level + 1) * 2;
- char indent[count + 1];
- for (uint32_t i = 0; i < count; i++) {
- indent[i] = ' ';
- }
- indent[count] = '\0';
- ALOGD("%sStart display list (%p, %s, render=%d)", (char*) indent + 2, this,
+void DisplayList::output(uint32_t level) {
+ ALOGD("%*sStart display list (%p, %s, render=%d)", level * 2, "", this,
mName.string(), isRenderable());
- ALOGD("%s%s %d", indent, "Save", SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
- int saveCount = renderer.getSaveCount() - 1;
-
- outputViewProperties(renderer, (char*) indent);
- mReader.rewind();
-
- while (!mReader.eof()) {
- int op = mReader.readInt();
- if (op & OP_MAY_BE_SKIPPED_MASK) {
- int skip = mReader.readInt();
- ALOGD("%sSkip %d", (char*) indent, skip);
- op &= ~OP_MAY_BE_SKIPPED_MASK;
- }
-
- switch (op) {
- case DrawGLFunction: {
- Functor *functor = (Functor *) getInt();
- ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor);
- }
- break;
- case Save: {
- int rendererNum = getInt();
- ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum);
- }
- break;
- case Restore: {
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case RestoreToCount: {
- int restoreCount = saveCount + getInt();
- ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount);
- }
- break;
- case SaveLayer: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- int flags = getInt();
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent,
- OP_NAMES[op], f1, f2, f3, f4, paint, flags);
- }
- break;
- case SaveLayerAlpha: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- int alpha = getInt();
- int flags = getInt();
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent,
- OP_NAMES[op], f1, f2, f3, f4, alpha, flags);
- }
- break;
- case Translate: {
- float f1 = getFloat();
- float f2 = getFloat();
- ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2);
- }
- break;
- case Rotate: {
- float rotation = getFloat();
- ALOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation);
- }
- break;
- case Scale: {
- float sx = getFloat();
- float sy = getFloat();
- ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy);
- }
- break;
- case Skew: {
- float sx = getFloat();
- float sy = getFloat();
- ALOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy);
- }
- break;
- case SetMatrix: {
- SkMatrix* matrix = getMatrix();
- ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix);
- }
- break;
- case ConcatMatrix: {
- SkMatrix* matrix = getMatrix();
- ALOGD("%s%s new concat %p: [%f, %f, %f] [%f, %f, %f] [%f, %f, %f]",
- (char*) indent, OP_NAMES[op], matrix, matrix->get(0), matrix->get(1),
- matrix->get(2), matrix->get(3), matrix->get(4), matrix->get(5),
- matrix->get(6), matrix->get(7), matrix->get(8));
- }
- break;
- case ClipRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- int regionOp = getInt();
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op],
- f1, f2, f3, f4, regionOp);
- }
- break;
- case ClipPath: {
- SkPath* path = getPath();
- int regionOp = getInt();
- ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], regionOp);
- }
- break;
- case ClipRegion: {
- SkRegion* region = getRegion();
- int regionOp = getInt();
- ALOGD("%s%s %d", (char*) indent, OP_NAMES[op], regionOp);
- }
- break;
- case DrawDisplayList: {
- DisplayList* displayList = getDisplayList();
- int32_t flags = getInt();
- ALOGD("%s%s %p, %dx%d, 0x%x %d", (char*) indent, OP_NAMES[op],
- displayList, mWidth, mHeight, flags, level + 1);
- renderer.outputDisplayList(displayList, level + 1);
- }
- break;
- case DrawLayer: {
- Layer* layer = (Layer*) getInt();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- layer, x, y, paint);
- }
- break;
- case DrawBitmap: {
- SkBitmap* bitmap = getBitmap();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- bitmap, x, y, paint);
- }
- break;
- case DrawBitmapMatrix: {
- SkBitmap* bitmap = getBitmap();
- SkMatrix* matrix = getMatrix();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op],
- bitmap, matrix, paint);
- }
- break;
- case DrawBitmapRect: {
- SkBitmap* bitmap = getBitmap();
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- float f7 = getFloat();
- float f8 = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint);
- }
- break;
- case DrawBitmapData: {
- SkBitmap* bitmap = getBitmapData();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %p", (char*) indent, OP_NAMES[op], x, y, paint);
- }
- break;
- case DrawBitmapMesh: {
- int verticesCount = 0;
- uint32_t colorsCount = 0;
- SkBitmap* bitmap = getBitmap();
- uint32_t meshWidth = getInt();
- uint32_t meshHeight = getInt();
- float* vertices = getFloats(verticesCount);
- bool hasColors = getInt();
- int* colors = hasColors ? getInts(colorsCount) : NULL;
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case DrawPatch: {
- int32_t* xDivs = NULL;
- int32_t* yDivs = NULL;
- uint32_t* colors = NULL;
- uint32_t xDivsCount = 0;
- uint32_t yDivsCount = 0;
- int8_t numColors = 0;
- SkBitmap* bitmap = getBitmap();
- xDivs = getInts(xDivsCount);
- yDivs = getInts(yDivsCount);
- colors = getUInts(numColors);
- float left = getFloat();
- float top = getFloat();
- float right = getFloat();
- float bottom = getFloat();
- int alpha = getInt();
- SkXfermode::Mode mode = (SkXfermode::Mode) getInt();
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f", (char*) indent, OP_NAMES[op],
- left, top, right, bottom);
- }
- break;
- case DrawColor: {
- int color = getInt();
- int xferMode = getInt();
- ALOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode);
- }
- break;
- case DrawRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- f1, f2, f3, f4, paint);
- }
- break;
- case DrawRoundRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint);
- }
- break;
- case DrawCircle: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, paint);
- }
- break;
- case DrawOval: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint);
- }
- break;
- case DrawArc: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- int i1 = getInt();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint);
- }
- break;
- case DrawPath: {
- SkPath* path = getPath();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint);
- }
- break;
- case DrawLines: {
- int count = 0;
- float* points = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case DrawPoints: {
- int count = 0;
- float* points = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case DrawTextOnPath: {
- getText(&text);
- int32_t count = getInt();
- SkPath* path = getPath();
- float hOffset = getFloat();
- float vOffset = getFloat();
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op],
- text.text(), text.length(), count, paint);
- }
- break;
- case DrawPosText: {
- getText(&text);
- int count = getInt();
- int positionsCount = 0;
- float* positions = getFloats(positionsCount);
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op],
- text.text(), text.length(), count, paint);
- }
- break;
- case DrawText: {
- getText(&text);
- int32_t count = getInt();
- float x = getFloat();
- float y = getFloat();
- int32_t positionsCount = 0;
- float* positions = getFloats(positionsCount);
- SkPaint* paint = getPaint(renderer);
- float length = getFloat();
- ALOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op],
- text.text(), text.length(), count, paint);
- }
- break;
- case DrawRects: {
- int32_t count = 0;
- float* rects = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- ALOGD("%s%s %d, %p", (char*) indent, OP_NAMES[op], count / 4, paint);
- }
- break;
- case ResetShader: {
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case SetupShader: {
- SkiaShader* shader = getShader();
- ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader);
- }
- break;
- case ResetColorFilter: {
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case SetupColorFilter: {
- SkiaColorFilter *colorFilter = getColorFilter();
- ALOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter);
- }
- break;
- case ResetShadow: {
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case SetupShadow: {
- float radius = getFloat();
- float dx = getFloat();
- float dy = getFloat();
- int color = getInt();
- ALOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op],
- radius, dx, dy, color);
- }
- break;
- case ResetPaintFilter: {
- ALOGD("%s%s", (char*) indent, OP_NAMES[op]);
- }
- break;
- case SetupPaintFilter: {
- int clearBits = getInt();
- int setBits = getInt();
- ALOGD("%s%s 0x%x, 0x%x", (char*) indent, OP_NAMES[op], clearBits, setBits);
- }
- break;
- default:
- ALOGD("Display List error: op not handled: %s%s",
- (char*) indent, OP_NAMES[op]);
- break;
- }
+ ALOGD("%*s%s %d", level * 4, "", "Save", SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
+ outputViewProperties(level);
+ int flags = DisplayListOp::kOpLogFlag_Recurse;
+ for (unsigned int i = 0; i < mDisplayListData->displayListOps.size(); i++) {
+ mDisplayListData->displayListOps[i]->output(level, flags);
}
- ALOGD("%sDone (%p, %s)", (char*) indent + 2, this, mName.string());
+ ALOGD("%*sDone (%p, %s)", level * 2, "", this, mName.string());
}
void DisplayList::updateMatrix() {
@@ -743,115 +316,68 @@
}
}
-void DisplayList::outputViewProperties(OpenGLRenderer& renderer, char* indent) {
+void DisplayList::outputViewProperties(uint32_t level) {
updateMatrix();
if (mLeft != 0 || mTop != 0) {
- ALOGD("%s%s %d, %d", indent, "Translate (left, top)", mLeft, mTop);
+ ALOGD("%*sTranslate (left, top) %d, %d", level * 2, "", mLeft, mTop);
}
if (mStaticMatrix) {
- ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix (static)", mStaticMatrix,
- mStaticMatrix->get(0), mStaticMatrix->get(1),
- mStaticMatrix->get(2), mStaticMatrix->get(3),
- mStaticMatrix->get(4), mStaticMatrix->get(5),
- mStaticMatrix->get(6), mStaticMatrix->get(7),
- mStaticMatrix->get(8));
+ ALOGD("%*sConcatMatrix (static) %p: " MATRIX_STRING,
+ level * 2, "", mStaticMatrix, MATRIX_ARGS(mStaticMatrix));
}
if (mAnimationMatrix) {
- ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix (animation)", mAnimationMatrix,
- mAnimationMatrix->get(0), mAnimationMatrix->get(1),
- mAnimationMatrix->get(2), mAnimationMatrix->get(3),
- mAnimationMatrix->get(4), mAnimationMatrix->get(5),
- mAnimationMatrix->get(6), mAnimationMatrix->get(7),
- mAnimationMatrix->get(8));
+ ALOGD("%*sConcatMatrix (animation) %p: " MATRIX_STRING,
+ level * 2, "", mAnimationMatrix, MATRIX_ARGS(mStaticMatrix));
}
if (mMatrixFlags != 0) {
if (mMatrixFlags == TRANSLATION) {
- ALOGD("%s%s %f, %f", indent, "Translate", mTranslationX, mTranslationY);
+ ALOGD("%*sTranslate %f, %f", level * 2, "", mTranslationX, mTranslationY);
} else {
- ALOGD("%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix", mTransformMatrix,
- mTransformMatrix->get(0), mTransformMatrix->get(1),
- mTransformMatrix->get(2), mTransformMatrix->get(3),
- mTransformMatrix->get(4), mTransformMatrix->get(5),
- mTransformMatrix->get(6), mTransformMatrix->get(7),
- mTransformMatrix->get(8));
+ ALOGD("%*sConcatMatrix %p: " MATRIX_STRING,
+ level * 2, "", mTransformMatrix, MATRIX_ARGS(mTransformMatrix));
}
}
if (mAlpha < 1 && !mCaching) {
if (!mHasOverlappingRendering) {
- ALOGD("%s%s %.2f", indent, "SetAlpha", mAlpha);
+ ALOGD("%*sSetAlpha %.2f", level * 2, "", mAlpha);
} else {
int flags = SkCanvas::kHasAlphaLayer_SaveFlag;
if (mClipChildren) {
flags |= SkCanvas::kClipToLayer_SaveFlag;
}
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", indent, "SaveLayerAlpha",
+ ALOGD("%*sSaveLayerAlpha %.2f, %.2f, %.2f, %.2f, %d, 0x%x", level * 2, "",
(float) 0, (float) 0, (float) mRight - mLeft, (float) mBottom - mTop,
mMultipliedAlpha, flags);
}
}
if (mClipChildren) {
- ALOGD("%s%s %.2f, %.2f, %.2f, %.2f", indent, "ClipRect", 0.0f, 0.0f,
+ ALOGD("%*sClipRect %.2f, %.2f, %.2f, %.2f", level * 2, "", 0.0f, 0.0f,
(float) mRight - mLeft, (float) mBottom - mTop);
}
}
void DisplayList::setViewProperties(OpenGLRenderer& renderer, uint32_t level) {
-#if DEBUG_DISPLAY_LIST
- uint32_t count = (level + 1) * 2;
- char indent[count + 1];
- for (uint32_t i = 0; i < count; i++) {
- indent[i] = ' ';
- }
- indent[count] = '\0';
+#if DEBUG_DISPLAYLIST
+ outputViewProperties(level);
#endif
updateMatrix();
if (mLeft != 0 || mTop != 0) {
- DISPLAY_LIST_LOGD("%s%s %d, %d", indent, "Translate (left, top)", mLeft, mTop);
renderer.translate(mLeft, mTop);
}
if (mStaticMatrix) {
- DISPLAY_LIST_LOGD(
- "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix (static)", mStaticMatrix,
- mStaticMatrix->get(0), mStaticMatrix->get(1),
- mStaticMatrix->get(2), mStaticMatrix->get(3),
- mStaticMatrix->get(4), mStaticMatrix->get(5),
- mStaticMatrix->get(6), mStaticMatrix->get(7),
- mStaticMatrix->get(8));
renderer.concatMatrix(mStaticMatrix);
} else if (mAnimationMatrix) {
- DISPLAY_LIST_LOGD(
- "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix (animation)", mAnimationMatrix,
- mAnimationMatrix->get(0), mAnimationMatrix->get(1),
- mAnimationMatrix->get(2), mAnimationMatrix->get(3),
- mAnimationMatrix->get(4), mAnimationMatrix->get(5),
- mAnimationMatrix->get(6), mAnimationMatrix->get(7),
- mAnimationMatrix->get(8));
renderer.concatMatrix(mAnimationMatrix);
}
if (mMatrixFlags != 0) {
if (mMatrixFlags == TRANSLATION) {
- DISPLAY_LIST_LOGD("%s%s %f, %f", indent, "Translate", mTranslationX, mTranslationY);
renderer.translate(mTranslationX, mTranslationY);
} else {
- DISPLAY_LIST_LOGD(
- "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- indent, "ConcatMatrix", mTransformMatrix,
- mTransformMatrix->get(0), mTransformMatrix->get(1),
- mTransformMatrix->get(2), mTransformMatrix->get(3),
- mTransformMatrix->get(4), mTransformMatrix->get(5),
- mTransformMatrix->get(6), mTransformMatrix->get(7),
- mTransformMatrix->get(8));
renderer.concatMatrix(mTransformMatrix);
}
}
if (mAlpha < 1 && !mCaching) {
if (!mHasOverlappingRendering) {
- DISPLAY_LIST_LOGD("%s%s %.2f", indent, "SetAlpha", mAlpha);
renderer.setAlpha(mAlpha);
} else {
// TODO: should be able to store the size of a DL at record time and not
@@ -861,53 +387,35 @@
if (mClipChildren) {
flags |= SkCanvas::kClipToLayer_SaveFlag;
}
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", indent, "SaveLayerAlpha",
- (float) 0, (float) 0, (float) mRight - mLeft, (float) mBottom - mTop,
- mMultipliedAlpha, flags);
renderer.saveLayerAlpha(0, 0, mRight - mLeft, mBottom - mTop,
mMultipliedAlpha, flags);
}
}
if (mClipChildren) {
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f", indent, "ClipRect", 0.0f, 0.0f,
- (float) mRight - mLeft, (float) mBottom - mTop);
renderer.clipRect(0, 0, mRight - mLeft, mBottom - mTop,
SkRegion::kIntersect_Op);
}
}
-/**
- * Changes to replay(), specifically those involving opcode or parameter changes, should be mimicked
- * in the output() function, since that function processes the same list of opcodes for the
- * purposes of logging display list info for a given view.
- */
status_t DisplayList::replay(OpenGLRenderer& renderer, Rect& dirty, int32_t flags, uint32_t level) {
status_t drawGlStatus = DrawGlInfo::kStatusDone;
- TextContainer text;
- mReader.rewind();
#if DEBUG_DISPLAY_LIST
- uint32_t count = (level + 1) * 2;
- char indent[count + 1];
- for (uint32_t i = 0; i < count; i++) {
- indent[i] = ' ';
- }
- indent[count] = '\0';
Rect* clipRect = renderer.getClipRect();
- DISPLAY_LIST_LOGD("%sStart display list (%p, %s), clipRect: %.0f, %.f, %.0f, %.0f",
- (char*) indent + 2, this, mName.string(), clipRect->left, clipRect->top,
+ DISPLAY_LIST_LOGD("%*sStart display list (%p, %s), clipRect: %.0f, %.f, %.0f, %.0f",
+ (level+1)*2, "", this, mName.string(), clipRect->left, clipRect->top,
clipRect->right, clipRect->bottom);
#endif
renderer.startMark(mName.string());
int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
- DISPLAY_LIST_LOGD("%s%s %d %d", indent, "Save",
+ DISPLAY_LIST_LOGD("%*sSave %d %d", level * 2, "",
SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag, restoreTo);
setViewProperties(renderer, level);
if (renderer.quickRejectNoScissor(0, 0, mWidth, mHeight)) {
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, "RestoreToCount", restoreTo);
+ DISPLAY_LIST_LOGD("%*sRestoreToCount %d", level * 2, "", restoreTo);
renderer.restoreToCount(restoreTo);
renderer.endMark();
return drawGlStatus;
@@ -915,469 +423,22 @@
DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
int saveCount = renderer.getSaveCount() - 1;
-
- while (!mReader.eof()) {
- int op = mReader.readInt();
- if (op & OP_MAY_BE_SKIPPED_MASK) {
- int32_t skip = mReader.readInt();
- if (CC_LIKELY(flags & kReplayFlag_ClipChildren)) {
- mReader.skip(skip);
- DISPLAY_LIST_LOGD("%s%s skipping %d bytes", (char*) indent,
- OP_NAMES[op & ~OP_MAY_BE_SKIPPED_MASK], skip);
- continue;
- } else {
- op &= ~OP_MAY_BE_SKIPPED_MASK;
- }
- }
- logBuffer.writeCommand(level, op);
-
+ for (unsigned int i = 0; i < mDisplayListData->displayListOps.size(); i++) {
+ DisplayListOp *op = mDisplayListData->displayListOps[i];
#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS
- Caches::getInstance().eventMark(strlen(OP_NAMES[op]), OP_NAMES[op]);
+ Caches::getInstance().eventMark(strlen(op->name()), op->name());
#endif
- switch (op) {
- case DrawGLFunction: {
- Functor *functor = (Functor *) getInt();
- DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], functor);
- renderer.startMark("GL functor");
- drawGlStatus |= renderer.callDrawGLFunction(functor, dirty);
- renderer.endMark();
- }
- break;
- case Save: {
- int32_t rendererNum = getInt();
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], rendererNum);
- renderer.save(rendererNum);
- }
- break;
- case Restore: {
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- renderer.restore();
- }
- break;
- case RestoreToCount: {
- int32_t restoreCount = saveCount + getInt();
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], restoreCount);
- renderer.restoreToCount(restoreCount);
- }
- break;
- case SaveLayer: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- int32_t flags = getInt();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p, 0x%x", (char*) indent,
- OP_NAMES[op], f1, f2, f3, f4, paint, flags);
- renderer.saveLayer(f1, f2, f3, f4, paint, flags);
- }
- break;
- case SaveLayerAlpha: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- int32_t alpha = getInt();
- int32_t flags = getInt();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d, 0x%x", (char*) indent,
- OP_NAMES[op], f1, f2, f3, f4, alpha, flags);
- renderer.saveLayerAlpha(f1, f2, f3, f4, alpha, flags);
- }
- break;
- case Translate: {
- float f1 = getFloat();
- float f2 = getFloat();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], f1, f2);
- renderer.translate(f1, f2);
- }
- break;
- case Rotate: {
- float rotation = getFloat();
- DISPLAY_LIST_LOGD("%s%s %.2f", (char*) indent, OP_NAMES[op], rotation);
- renderer.rotate(rotation);
- }
- break;
- case Scale: {
- float sx = getFloat();
- float sy = getFloat();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy);
- renderer.scale(sx, sy);
- }
- break;
- case Skew: {
- float sx = getFloat();
- float sy = getFloat();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f", (char*) indent, OP_NAMES[op], sx, sy);
- renderer.skew(sx, sy);
- }
- break;
- case SetMatrix: {
- SkMatrix* matrix = getMatrix();
- DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], matrix);
- renderer.setMatrix(matrix);
- }
- break;
- case ConcatMatrix: {
- SkMatrix* matrix = getMatrix();
- DISPLAY_LIST_LOGD(
- "%s%s %p: [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f] [%.2f, %.2f, %.2f]",
- (char*) indent, OP_NAMES[op], matrix,
- matrix->get(0), matrix->get(1), matrix->get(2),
- matrix->get(3), matrix->get(4), matrix->get(5),
- matrix->get(6), matrix->get(7), matrix->get(8));
- renderer.concatMatrix(matrix);
- }
- break;
- case ClipRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- int32_t regionOp = getInt();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %d", (char*) indent, OP_NAMES[op],
- f1, f2, f3, f4, regionOp);
- renderer.clipRect(f1, f2, f3, f4, (SkRegion::Op) regionOp);
- }
- break;
- case ClipPath: {
- SkPath* path = getPath();
- int32_t regionOp = getInt();
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], regionOp);
- renderer.clipPath(path, (SkRegion::Op) regionOp);
- }
- break;
- case ClipRegion: {
- SkRegion* region = getRegion();
- int32_t regionOp = getInt();
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, OP_NAMES[op], regionOp);
- renderer.clipRegion(region, (SkRegion::Op) regionOp);
- }
- break;
- case DrawDisplayList: {
- DisplayList* displayList = getDisplayList();
- int32_t flags = getInt();
- DISPLAY_LIST_LOGD("%s%s %p, %dx%d, 0x%x %d", (char*) indent, OP_NAMES[op],
- displayList, mWidth, mHeight, flags, level + 1);
- drawGlStatus |= renderer.drawDisplayList(displayList, dirty, flags, level + 1);
- }
- break;
- case DrawLayer: {
- int oldAlpha = -1;
- Layer* layer = (Layer*) getInt();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- if (mCaching && mMultipliedAlpha < 255) {
- oldAlpha = layer->getAlpha();
- layer->setAlpha(mMultipliedAlpha);
- }
- DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- layer, x, y, paint);
- drawGlStatus |= renderer.drawLayer(layer, x, y, paint);
- if (oldAlpha >= 0) {
- layer->setAlpha(oldAlpha);
- }
- }
- break;
- case DrawBitmap: {
- int oldAlpha = -1;
- SkBitmap* bitmap = getBitmap();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- if (mCaching && mMultipliedAlpha < 255) {
- oldAlpha = paint->getAlpha();
- paint->setAlpha(mMultipliedAlpha);
- }
- DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- bitmap, x, y, paint);
- drawGlStatus |= renderer.drawBitmap(bitmap, x, y, paint);
- if (oldAlpha >= 0) {
- paint->setAlpha(oldAlpha);
- }
- }
- break;
- case DrawBitmapMatrix: {
- SkBitmap* bitmap = getBitmap();
- SkMatrix* matrix = getMatrix();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %p, %p, %p", (char*) indent, OP_NAMES[op],
- bitmap, matrix, paint);
- drawGlStatus |= renderer.drawBitmap(bitmap, matrix, paint);
- }
- break;
- case DrawBitmapRect: {
- SkBitmap* bitmap = getBitmap();
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- float f7 = getFloat();
- float f8 = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], bitmap,
- f1, f2, f3, f4, f5, f6, f7, f8,paint);
- drawGlStatus |= renderer.drawBitmap(bitmap, f1, f2, f3, f4, f5, f6, f7, f8, paint);
- }
- break;
- case DrawBitmapData: {
- SkBitmap* bitmap = getBitmapData();
- float x = getFloat();
- float y = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %p, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- bitmap, x, y, paint);
- drawGlStatus |= renderer.drawBitmap(bitmap, x, y, paint);
- }
- break;
- case DrawBitmapMesh: {
- int32_t verticesCount = 0;
- uint32_t colorsCount = 0;
-
- SkBitmap* bitmap = getBitmap();
- uint32_t meshWidth = getInt();
- uint32_t meshHeight = getInt();
- float* vertices = getFloats(verticesCount);
- bool hasColors = getInt();
- int32_t* colors = hasColors ? getInts(colorsCount) : NULL;
- SkPaint* paint = getPaint(renderer);
-
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- drawGlStatus |= renderer.drawBitmapMesh(bitmap, meshWidth, meshHeight, vertices,
- colors, paint);
- }
- break;
- case DrawPatch: {
- int32_t* xDivs = NULL;
- int32_t* yDivs = NULL;
- uint32_t* colors = NULL;
- uint32_t xDivsCount = 0;
- uint32_t yDivsCount = 0;
- int8_t numColors = 0;
-
- SkBitmap* bitmap = getBitmap();
-
- xDivs = getInts(xDivsCount);
- yDivs = getInts(yDivsCount);
- colors = getUInts(numColors);
-
- float left = getFloat();
- float top = getFloat();
- float right = getFloat();
- float bottom = getFloat();
-
- int alpha = getInt();
- SkXfermode::Mode mode = (SkXfermode::Mode) getInt();
-
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- drawGlStatus |= renderer.drawPatch(bitmap, xDivs, yDivs, colors,
- xDivsCount, yDivsCount, numColors, left, top, right, bottom,
- alpha, mode);
- }
- break;
- case DrawColor: {
- int32_t color = getInt();
- int32_t xferMode = getInt();
- DISPLAY_LIST_LOGD("%s%s 0x%x %d", (char*) indent, OP_NAMES[op], color, xferMode);
- drawGlStatus |= renderer.drawColor(color, (SkXfermode::Mode) xferMode);
- }
- break;
- case DrawRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p", (char*) indent, OP_NAMES[op],
- f1, f2, f3, f4, paint);
- drawGlStatus |= renderer.drawRect(f1, f2, f3, f4, paint);
- }
- break;
- case DrawRoundRect: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, paint);
- drawGlStatus |= renderer.drawRoundRect(f1, f2, f3, f4, f5, f6, paint);
- }
- break;
- case DrawCircle: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, paint);
- drawGlStatus |= renderer.drawCircle(f1, f2, f3, paint);
- }
- break;
- case DrawOval: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, paint);
- drawGlStatus |= renderer.drawOval(f1, f2, f3, f4, paint);
- }
- break;
- case DrawArc: {
- float f1 = getFloat();
- float f2 = getFloat();
- float f3 = getFloat();
- float f4 = getFloat();
- float f5 = getFloat();
- float f6 = getFloat();
- int32_t i1 = getInt();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p",
- (char*) indent, OP_NAMES[op], f1, f2, f3, f4, f5, f6, i1, paint);
- drawGlStatus |= renderer.drawArc(f1, f2, f3, f4, f5, f6, i1 == 1, paint);
- }
- break;
- case DrawPath: {
- SkPath* path = getPath();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %p, %p", (char*) indent, OP_NAMES[op], path, paint);
- drawGlStatus |= renderer.drawPath(path, paint);
- }
- break;
- case DrawLines: {
- int32_t count = 0;
- float* points = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- drawGlStatus |= renderer.drawLines(points, count, paint);
- }
- break;
- case DrawPoints: {
- int32_t count = 0;
- float* points = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- drawGlStatus |= renderer.drawPoints(points, count, paint);
- }
- break;
- case DrawTextOnPath: {
- getText(&text);
- int32_t count = getInt();
- SkPath* path = getPath();
- float hOffset = getFloat();
- float vOffset = getFloat();
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %p", (char*) indent, OP_NAMES[op],
- text.text(), text.length(), count, paint);
- drawGlStatus |= renderer.drawTextOnPath(text.text(), text.length(), count, path,
- hOffset, vOffset, paint);
- }
- break;
- case DrawPosText: {
- getText(&text);
- int32_t count = getInt();
- int32_t positionsCount = 0;
- float* positions = getFloats(positionsCount);
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %p", (char*) indent,
- OP_NAMES[op], text.text(), text.length(), count, paint);
- drawGlStatus |= renderer.drawPosText(text.text(), text.length(), count,
- positions, paint);
- }
- break;
- case DrawText: {
- getText(&text);
- int32_t count = getInt();
- float x = getFloat();
- float y = getFloat();
- int32_t positionsCount = 0;
- float* positions = getFloats(positionsCount);
- SkPaint* paint = getPaint(renderer);
- float length = getFloat();
- DISPLAY_LIST_LOGD("%s%s %s, %d, %d, %.2f, %.2f, %p, %.2f", (char*) indent,
- OP_NAMES[op], text.text(), text.length(), count, x, y, paint, length);
- drawGlStatus |= renderer.drawText(text.text(), text.length(), count,
- x, y, positions, paint, length);
- }
- break;
- case DrawRects: {
- int32_t count = 0;
- float* rects = getFloats(count);
- SkPaint* paint = getPaint(renderer);
- DISPLAY_LIST_LOGD("%s%s %d, %p", (char*) indent, OP_NAMES[op], count, paint);
- drawGlStatus |= renderer.drawRects(rects, count / 4, paint);
- }
- break;
- case ResetShader: {
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- renderer.resetShader();
- }
- break;
- case SetupShader: {
- SkiaShader* shader = getShader();
- DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], shader);
- renderer.setupShader(shader);
- }
- break;
- case ResetColorFilter: {
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- renderer.resetColorFilter();
- }
- break;
- case SetupColorFilter: {
- SkiaColorFilter *colorFilter = getColorFilter();
- DISPLAY_LIST_LOGD("%s%s %p", (char*) indent, OP_NAMES[op], colorFilter);
- renderer.setupColorFilter(colorFilter);
- }
- break;
- case ResetShadow: {
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- renderer.resetShadow();
- }
- break;
- case SetupShadow: {
- float radius = getFloat();
- float dx = getFloat();
- float dy = getFloat();
- int32_t color = getInt();
- DISPLAY_LIST_LOGD("%s%s %.2f, %.2f, %.2f, 0x%x", (char*) indent, OP_NAMES[op],
- radius, dx, dy, color);
- renderer.setupShadow(radius, dx, dy, color);
- }
- break;
- case ResetPaintFilter: {
- DISPLAY_LIST_LOGD("%s%s", (char*) indent, OP_NAMES[op]);
- renderer.resetPaintFilter();
- }
- break;
- case SetupPaintFilter: {
- int32_t clearBits = getInt();
- int32_t setBits = getInt();
- DISPLAY_LIST_LOGD("%s%s 0x%x, 0x%x", (char*) indent, OP_NAMES[op],
- clearBits, setBits);
- renderer.setupPaintFilter(clearBits, setBits);
- }
- break;
- default:
- DISPLAY_LIST_LOGD("Display List error: op not handled: %s%s",
- (char*) indent, OP_NAMES[op]);
- break;
- }
+ drawGlStatus |= op->replay(renderer, dirty, flags,
+ saveCount, level, mCaching, mMultipliedAlpha);
+ logBuffer.writeCommand(level, op->name());
}
- DISPLAY_LIST_LOGD("%s%s %d", (char*) indent, "RestoreToCount", restoreTo);
+ DISPLAY_LIST_LOGD("%*sRestoreToCount %d", level * 2, "", restoreTo);
renderer.restoreToCount(restoreTo);
renderer.endMark();
- DISPLAY_LIST_LOGD("%sDone (%p, %s), returning %d", (char*) indent + 2, this, mName.string(),
+ DISPLAY_LIST_LOGD("%*sDone (%p, %s), returning %d", (level + 1) * 2, "", this, mName.string(),
drawGlStatus);
return drawGlStatus;
}
@@ -1387,7 +448,7 @@
///////////////////////////////////////////////////////////////////////////////
DisplayListRenderer::DisplayListRenderer():
- mCaches(Caches::getInstance()), mWriter(MIN_WRITER_SIZE),
+ mCaches(Caches::getInstance()), mDisplayListData(new DisplayListData),
mTranslateX(0.0f), mTranslateY(0.0f), mHasTranslate(false),
mHasDrawOps(false), mFunctorCount(0) {
}
@@ -1397,8 +458,7 @@
}
void DisplayListRenderer::reset() {
- mWriter.reset();
-
+ mDisplayListData = new DisplayListData();
mCaches.resourceCache.lock();
for (size_t i = 0; i < mBitmapResources.size(); i++) {
@@ -1493,7 +553,7 @@
void DisplayListRenderer::finish() {
insertRestoreToCount();
- insertTranlate();
+ insertTranslate();
}
void DisplayListRenderer::interrupt() {
@@ -1504,15 +564,13 @@
status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) {
// Ignore dirty during recording, it matters only when we replay
- addOp(DisplayList::DrawGLFunction);
- addInt((int) functor);
+ addDrawOp(new (alloc()) DrawFunctorOp(functor));
mFunctorCount++;
return DrawGlInfo::kStatusDone; // No invalidate needed at record-time
}
int DisplayListRenderer::save(int flags) {
- addOp(DisplayList::Save);
- addInt(flags);
+ addStateOp(new (alloc()) SaveOp(flags));
return OpenGLRenderer::save(flags);
}
@@ -1523,31 +581,25 @@
}
mRestoreSaveCount--;
- insertTranlate();
+ insertTranslate();
OpenGLRenderer::restore();
}
void DisplayListRenderer::restoreToCount(int saveCount) {
mRestoreSaveCount = saveCount;
- insertTranlate();
+ insertTranslate();
OpenGLRenderer::restoreToCount(saveCount);
}
int DisplayListRenderer::saveLayer(float left, float top, float right, float bottom,
SkPaint* p, int flags) {
- addOp(DisplayList::SaveLayer);
- addBounds(left, top, right, bottom);
- addPaint(p);
- addInt(flags);
+ addStateOp(new (alloc()) SaveLayerOp(left, top, right, bottom, p, flags));
return OpenGLRenderer::save(flags);
}
int DisplayListRenderer::saveLayerAlpha(float left, float top, float right, float bottom,
int alpha, int flags) {
- addOp(DisplayList::SaveLayerAlpha);
- addBounds(left, top, right, bottom);
- addInt(alpha);
- addInt(flags);
+ addStateOp(new (alloc()) SaveLayerAlphaOp(left, top, right, bottom, alpha, flags));
return OpenGLRenderer::save(flags);
}
@@ -1560,54 +612,47 @@
}
void DisplayListRenderer::rotate(float degrees) {
- addOp(DisplayList::Rotate);
- addFloat(degrees);
+ addStateOp(new (alloc()) RotateOp(degrees));
OpenGLRenderer::rotate(degrees);
}
void DisplayListRenderer::scale(float sx, float sy) {
- addOp(DisplayList::Scale);
- addPoint(sx, sy);
+ addStateOp(new (alloc()) ScaleOp(sx, sy));
OpenGLRenderer::scale(sx, sy);
}
void DisplayListRenderer::skew(float sx, float sy) {
- addOp(DisplayList::Skew);
- addPoint(sx, sy);
+ addStateOp(new (alloc()) SkewOp(sx, sy));
OpenGLRenderer::skew(sx, sy);
}
void DisplayListRenderer::setMatrix(SkMatrix* matrix) {
- addOp(DisplayList::SetMatrix);
- addMatrix(matrix);
+ matrix = refMatrix(matrix);
+ addStateOp(new (alloc()) SetMatrixOp(matrix));
OpenGLRenderer::setMatrix(matrix);
}
void DisplayListRenderer::concatMatrix(SkMatrix* matrix) {
- addOp(DisplayList::ConcatMatrix);
- addMatrix(matrix);
+ matrix = refMatrix(matrix);
+ addStateOp(new (alloc()) ConcatMatrixOp(matrix));
OpenGLRenderer::concatMatrix(matrix);
}
bool DisplayListRenderer::clipRect(float left, float top, float right, float bottom,
SkRegion::Op op) {
- addOp(DisplayList::ClipRect);
- addBounds(left, top, right, bottom);
- addInt(op);
+ addStateOp(new (alloc()) ClipRectOp(left, top, right, bottom, op));
return OpenGLRenderer::clipRect(left, top, right, bottom, op);
}
bool DisplayListRenderer::clipPath(SkPath* path, SkRegion::Op op) {
- addOp(DisplayList::ClipPath);
- addPath(path);
- addInt(op);
+ path = refPath(path);
+ addStateOp(new (alloc()) ClipPathOp(path, op));
return OpenGLRenderer::clipPath(path, op);
}
bool DisplayListRenderer::clipRegion(SkRegion* region, SkRegion::Op op) {
- addOp(DisplayList::ClipRegion);
- addRegion(region);
- addInt(op);
+ region = refRegion(region);
+ addStateOp(new (alloc()) ClipRegionOp(region, op));
return OpenGLRenderer::clipRegion(region, op);
}
@@ -1616,84 +661,71 @@
// dirty is an out parameter and should not be recorded,
// it matters only when replaying the display list
- addOp(DisplayList::DrawDisplayList);
- addDisplayList(displayList);
- addInt(flags);
+ // TODO: To be safe, the display list should be ref-counted in the
+ // resources cache, but we rely on the caller (UI toolkit) to
+ // do the right thing for now
+
+ addDrawOp(new (alloc()) DrawDisplayListOp(displayList, flags));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* paint) {
- addOp(DisplayList::DrawLayer);
- addLayer(layer);
- addPoint(x, y);
- addPaint(paint);
+ mLayers.add(layer);
+ mCaches.resourceCache.incrementRefcount(layer);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawLayerOp(layer, x, y, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint) {
- const bool reject = quickRejectNoScissor(left, top,
- left + bitmap->width(), top + bitmap->height());
- uint32_t* location = addOp(DisplayList::DrawBitmap, reject);
- addBitmap(bitmap);
- addPoint(left, top);
- addPaint(paint);
- addSkip(location);
+ bitmap = refBitmap(bitmap);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawBitmapOp(bitmap, left, top, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) {
- Rect r(0.0f, 0.0f, bitmap->width(), bitmap->height());
- const mat4 transform(*matrix);
- transform.mapRect(r);
+ bitmap = refBitmap(bitmap);
+ matrix = refMatrix(matrix);
+ paint = refPaint(paint);
- const bool reject = quickRejectNoScissor(r.left, r.top, r.right, r.bottom);
- uint32_t* location = addOp(DisplayList::DrawBitmapMatrix, reject);
- addBitmap(bitmap);
- addMatrix(matrix);
- addPaint(paint);
- addSkip(location);
+ addDrawOp(new (alloc()) DrawBitmapMatrixOp(bitmap, matrix, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop,
float srcRight, float srcBottom, float dstLeft, float dstTop,
float dstRight, float dstBottom, SkPaint* paint) {
- const bool reject = quickRejectNoScissor(dstLeft, dstTop, dstRight, dstBottom);
- uint32_t* location = addOp(DisplayList::DrawBitmapRect, reject);
- addBitmap(bitmap);
- addBounds(srcLeft, srcTop, srcRight, srcBottom);
- addBounds(dstLeft, dstTop, dstRight, dstBottom);
- addPaint(paint);
- addSkip(location);
+ bitmap = refBitmap(bitmap);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawBitmapRectOp(bitmap,
+ srcLeft, srcTop, srcRight, srcBottom,
+ dstLeft, dstTop, dstRight, dstBottom, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawBitmapData(SkBitmap* bitmap, float left, float top,
SkPaint* paint) {
- const bool reject = quickRejectNoScissor(left, top,
- left + bitmap->width(), top + bitmap->height());
- uint32_t* location = addOp(DisplayList::DrawBitmapData, reject);
- addBitmapData(bitmap);
- addPoint(left, top);
- addPaint(paint);
- addSkip(location);
+ bitmap = refBitmapData(bitmap);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawBitmapDataOp(bitmap, left, top, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight,
float* vertices, int* colors, SkPaint* paint) {
- addOp(DisplayList::DrawBitmapMesh);
- addBitmap(bitmap);
- addInt(meshWidth);
- addInt(meshHeight);
- addFloats(vertices, (meshWidth + 1) * (meshHeight + 1) * 2);
- if (colors) {
- addInt(1);
- addInts(colors, (meshWidth + 1) * (meshHeight + 1));
- } else {
- addInt(0);
- }
- addPaint(paint);
+ int count = (meshWidth + 1) * (meshHeight + 1) * 2;
+ bitmap = refBitmap(bitmap);
+ vertices = refBuffer<float>(vertices, count);
+ paint = refPaint(paint);
+ colors = refBuffer<int>(colors, count);
+
+ addDrawOp(new (alloc()) DrawBitmapMeshOp(bitmap, meshWidth, meshHeight,
+ vertices, colors, paint));
return DrawGlInfo::kStatusDone;
}
@@ -1704,132 +736,114 @@
SkXfermode::Mode mode;
OpenGLRenderer::getAlphaAndModeDirect(paint, &alpha, &mode);
- const bool reject = quickRejectNoScissor(left, top, right, bottom);
- uint32_t* location = addOp(DisplayList::DrawPatch, reject);
- addBitmap(bitmap);
- addInts(xDivs, width);
- addInts(yDivs, height);
- addUInts(colors, numColors);
- addBounds(left, top, right, bottom);
- addInt(alpha);
- addInt(mode);
- addSkip(location);
+ bitmap = refBitmap(bitmap);
+ xDivs = refBuffer<int>(xDivs, width);
+ yDivs = refBuffer<int>(yDivs, height);
+ colors = refBuffer<uint32_t>(colors, numColors);
+
+ addDrawOp(new (alloc()) DrawPatchOp(bitmap, xDivs, yDivs, colors, width, height, numColors,
+ left, top, right, bottom, alpha, mode));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) {
- addOp(DisplayList::DrawColor);
- addInt(color);
- addInt(mode);
+ addDrawOp(new (alloc()) DrawColorOp(color, mode));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawRect(float left, float top, float right, float bottom,
SkPaint* paint) {
- const bool reject = paint->getStyle() == SkPaint::kFill_Style &&
- quickRejectNoScissor(left, top, right, bottom);
- uint32_t* location = addOp(DisplayList::DrawRect, reject);
- addBounds(left, top, right, bottom);
- addPaint(paint);
- addSkip(location);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawRectOp(left, top, right, bottom, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom,
float rx, float ry, SkPaint* paint) {
- const bool reject = paint->getStyle() == SkPaint::kFill_Style &&
- quickRejectNoScissor(left, top, right, bottom);
- uint32_t* location = addOp(DisplayList::DrawRoundRect, reject);
- addBounds(left, top, right, bottom);
- addPoint(rx, ry);
- addPaint(paint);
- addSkip(location);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawRoundRectOp(left, top, right, bottom, rx, ry, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawCircle(float x, float y, float radius, SkPaint* paint) {
- addOp(DisplayList::DrawCircle);
- addPoint(x, y);
- addFloat(radius);
- addPaint(paint);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawCircleOp(x, y, radius, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawOval(float left, float top, float right, float bottom,
SkPaint* paint) {
- addOp(DisplayList::DrawOval);
- addBounds(left, top, right, bottom);
- addPaint(paint);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawOvalOp(left, top, right, bottom, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawArc(float left, float top, float right, float bottom,
float startAngle, float sweepAngle, bool useCenter, SkPaint* paint) {
- addOp(DisplayList::DrawArc);
- addBounds(left, top, right, bottom);
- addPoint(startAngle, sweepAngle);
- addInt(useCenter ? 1 : 0);
- addPaint(paint);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawArcOp(left, top, right, bottom,
+ startAngle, sweepAngle, useCenter, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawPath(SkPath* path, SkPaint* paint) {
- float left, top, offset;
- uint32_t width, height;
- computePathBounds(path, paint, left, top, offset, width, height);
+ path = refPath(path);
+ paint = refPaint(paint);
- left -= offset;
- top -= offset;
-
- const bool reject = quickRejectNoScissor(left, top, left + width, top + height);
- uint32_t* location = addOp(DisplayList::DrawPath, reject);
- addPath(path);
- addPaint(paint);
- addSkip(location);
+ addDrawOp(new (alloc()) DrawPathOp(path, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawLines(float* points, int count, SkPaint* paint) {
- addOp(DisplayList::DrawLines);
- addFloats(points, count);
- addPaint(paint);
+ points = refBuffer<float>(points, count);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawLinesOp(points, count, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawPoints(float* points, int count, SkPaint* paint) {
- addOp(DisplayList::DrawPoints);
- addFloats(points, count);
- addPaint(paint);
+ points = refBuffer<float>(points, count);
+ paint = refPaint(paint);
+
+ addDrawOp(new (alloc()) DrawPointsOp(points, count, paint));
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
SkPath* path, float hOffset, float vOffset, SkPaint* paint) {
if (!text || count <= 0) return DrawGlInfo::kStatusDone;
- addOp(DisplayList::DrawTextOnPath);
- addText(text, bytesCount);
- addInt(count);
- addPath(path);
- addFloat(hOffset);
- addFloat(vOffset);
+
paint->setAntiAlias(true);
- SkPaint* addedPaint = addPaint(paint);
- FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint);
- fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform);
+ text = refText(text, bytesCount);
+ path = refPath(path);
+ paint = refPaint(paint);
+
+ DrawOp* op = new (alloc()) DrawTextOnPathOp(text, bytesCount, count, path,
+ hOffset, vOffset, paint);
+ if (addDrawOp(op)) {
+ // precache if draw operation is visible
+ FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+ fontRenderer.precache(paint, text, count, *mSnapshot->transform);
+ }
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawPosText(const char* text, int bytesCount, int count,
const float* positions, SkPaint* paint) {
if (!text || count <= 0) return DrawGlInfo::kStatusDone;
- addOp(DisplayList::DrawPosText);
- addText(text, bytesCount);
- addInt(count);
- addFloats(positions, count * 2);
+
paint->setAntiAlias(true);
- SkPaint* addedPaint = addPaint(paint);
- FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint);
- fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform);
+ text = refText(text, bytesCount);
+ positions = refBuffer<float>(positions, count * 2);
+ paint = refPaint(paint);
+
+ DrawOp* op = new (alloc()) DrawPosTextOp(text, bytesCount, count, positions, paint);
+ if (addDrawOp(op)) {
+ // precache if draw operation is visible
+ FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+ fontRenderer.precache(paint, text, count, *mSnapshot->transform);
+ }
return DrawGlInfo::kStatusDone;
}
@@ -1847,75 +861,96 @@
paint->setAntiAlias(true);
if (length < 0.0f) length = paint->measureText(text, bytesCount);
- bool reject = false;
- if (CC_LIKELY(paint->getTextAlign() == SkPaint::kLeft_Align)) {
- SkPaint::FontMetrics metrics;
- paint->getFontMetrics(&metrics, 0.0f);
- reject = quickRejectNoScissor(x, y + metrics.fTop, x + length, y + metrics.fBottom);
- }
+ text = refText(text, bytesCount);
+ positions = refBuffer<float>(positions, count * 2);
+ paint = refPaint(paint);
- uint32_t* location = addOp(DisplayList::DrawText, reject);
- addText(text, bytesCount);
- addInt(count);
- addFloat(x);
- addFloat(y);
- addFloats(positions, count * 2);
- SkPaint* addedPaint = addPaint(paint);
- if (!reject) {
- FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(addedPaint);
- fontRenderer.precache(addedPaint, text, count, *mSnapshot->transform);
+ DrawOp* op = new (alloc()) DrawTextOp(text, bytesCount, count, x, y, positions, paint, length);
+ if (addDrawOp(op)) {
+ // precache if draw operation is visible
+ FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+ fontRenderer.precache(paint, text, count, *mSnapshot->transform);
}
- addFloat(length);
- addSkip(location);
return DrawGlInfo::kStatusDone;
}
status_t DisplayListRenderer::drawRects(const float* rects, int count, SkPaint* paint) {
if (count <= 0) return DrawGlInfo::kStatusDone;
- addOp(DisplayList::DrawRects);
- addFloats(rects, count * 4);
- addPaint(paint);
+ rects = refBuffer<float>(rects, count);
+ paint = refPaint(paint);
+ addDrawOp(new (alloc()) DrawRectsOp(rects, count, paint));
return DrawGlInfo::kStatusDone;
}
void DisplayListRenderer::resetShader() {
- addOp(DisplayList::ResetShader);
+ addStateOp(new (alloc()) ResetShaderOp());
}
void DisplayListRenderer::setupShader(SkiaShader* shader) {
- addOp(DisplayList::SetupShader);
- addShader(shader);
+ shader = refShader(shader);
+ addStateOp(new (alloc()) SetupShaderOp(shader));
}
void DisplayListRenderer::resetColorFilter() {
- addOp(DisplayList::ResetColorFilter);
+ addStateOp(new (alloc()) ResetColorFilterOp());
}
void DisplayListRenderer::setupColorFilter(SkiaColorFilter* filter) {
- addOp(DisplayList::SetupColorFilter);
- addColorFilter(filter);
+ filter = refColorFilter(filter);
+ addStateOp(new (alloc()) SetupColorFilterOp(filter));
}
void DisplayListRenderer::resetShadow() {
- addOp(DisplayList::ResetShadow);
+ addStateOp(new (alloc()) ResetShadowOp());
}
void DisplayListRenderer::setupShadow(float radius, float dx, float dy, int color) {
- addOp(DisplayList::SetupShadow);
- addFloat(radius);
- addPoint(dx, dy);
- addInt(color);
+ addStateOp(new (alloc()) SetupShadowOp(radius, dx, dy, color));
}
void DisplayListRenderer::resetPaintFilter() {
- addOp(DisplayList::ResetPaintFilter);
+ addStateOp(new (alloc()) ResetPaintFilterOp());
}
void DisplayListRenderer::setupPaintFilter(int clearBits, int setBits) {
- addOp(DisplayList::SetupPaintFilter);
- addInt(clearBits);
- addInt(setBits);
+ addStateOp(new (alloc()) SetupPaintFilterOp(clearBits, setBits));
+}
+
+void DisplayListRenderer::insertRestoreToCount() {
+ if (mRestoreSaveCount >= 0) {
+ DisplayListOp* op = new (alloc()) RestoreToCountOp(mRestoreSaveCount);
+ mDisplayListData->displayListOps.add(op);
+ mRestoreSaveCount = -1;
+ }
+}
+
+void DisplayListRenderer::insertTranslate() {
+ if (mHasTranslate) {
+ if (mTranslateX != 0.0f || mTranslateY != 0.0f) {
+ DisplayListOp* op = new (alloc()) TranslateOp(mTranslateX, mTranslateY);
+ mDisplayListData->displayListOps.add(op);
+ mTranslateX = mTranslateY = 0.0f;
+ }
+ mHasTranslate = false;
+ }
+}
+
+void DisplayListRenderer::addStateOp(StateOp* op) {
+ addOpInternal(op);
+}
+
+bool DisplayListRenderer::addDrawOp(DrawOp* op) {
+ bool rejected = false;
+ Rect localBounds;
+ if (op->getLocalBounds(localBounds)) {
+ rejected = quickRejectNoScissor(localBounds.left, localBounds.top,
+ localBounds.right, localBounds.bottom);
+ op->setQuickRejected(rejected);
+ }
+ mHasDrawOps = true;
+ addOpInternal(op);
+ return !rejected;
}
}; // namespace uirenderer