Merge "Use snapshot alpha for layers" into jb-mr2-dev (4494599e) · Commits · e / os / android_frameworks_base

core/jni/android_view_GLES20Canvas.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -869,7 +869,8 @@ static void android_view_GLES20Canvas_destroyLayerDeferred(JNIEnv* env,

		static void android_view_GLES20Canvas_drawLayer(JNIEnv* env, jobject clazz,
		OpenGLRenderer* renderer, Layer* layer, jfloat x, jfloat y, SkPaint* paint) {
		renderer->drawLayer(layer, x, y, paint);
		// TODO: don't pass the paint from java
		renderer->drawLayer(layer, x, y);
		}

		static jboolean android_view_GLES20Canvas_copyLayer(JNIEnv* env, jobject clazz,

libs/hwui/DeferredDisplayList.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -80,7 +80,7 @@ public:
		#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS
		renderer.eventMark(strlen(op->name()), op->name());
		#endif
		status \|= op->applyDraw(renderer, dirty, 0, op->state.mMultipliedAlpha);
		status \|= op->applyDraw(renderer, dirty, 0);
		logBuffer.writeCommand(0, op->name());
		}
		return status;

libs/hwui/DisplayList.cpp

+13 −16

Original line number	Diff line number	Diff line
		@@ -233,7 +233,6 @@ void DisplayList::init() {
		mBottom = 0;
		mClipChildren = true;
		mAlpha = 1;
		mMultipliedAlpha = 255;
		mHasOverlappingRendering = true;
		mTranslationX = 0;
		mTranslationY = 0;
		@@ -362,7 +361,7 @@ void DisplayList::outputViewProperties(const int level) {
		}
		ALOGD("%sSaveLayerAlpha %.2f, %.2f, %.2f, %.2f, %d, 0x%x", level 2, "",
		(float) 0, (float) 0, (float) mRight - mLeft, (float) mBottom - mTop,
		mMultipliedAlpha, flags);
		(int)(mAlpha * 255), flags);
		}
		}
		if (mClipChildren && !mCaching) {
		@@ -400,9 +399,9 @@ void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,
		renderer.concatMatrix(mTransformMatrix);
		}
		}
		if (mAlpha < 1 && !mCaching) {
		if (!mHasOverlappingRendering) {
		renderer.setAlpha(mAlpha);
		if (mAlpha < 1) {
		if (mCaching \|\| !mHasOverlappingRendering) {
		renderer.scaleAlpha(mAlpha);
		} else {
		// TODO: should be able to store the size of a DL at record time and not
		// have to pass it into this call. In fact, this information might be in the
		@@ -412,7 +411,7 @@ void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,
		saveFlags \|= SkCanvas::kClipToLayer_SaveFlag;
		}
		handler(mSaveLayerOp->reinit(0, 0, mRight - mLeft, mBottom - mTop,
		mMultipliedAlpha, SkXfermode::kSrcOver_Mode, saveFlags), PROPERTY_SAVECOUNT);
		mAlpha * 255, SkXfermode::kSrcOver_Mode, saveFlags), PROPERTY_SAVECOUNT);
		}
		}
		if (mClipChildren && !mCaching) {
		@@ -423,40 +422,38 @@ void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,

		class DeferOperationHandler {
		public:
		DeferOperationHandler(DeferStateStruct& deferStruct, int multipliedAlpha, int level)
		: mDeferStruct(deferStruct), mMultipliedAlpha(multipliedAlpha), mLevel(level) {}
		DeferOperationHandler(DeferStateStruct& deferStruct, int level)
		: mDeferStruct(deferStruct), mLevel(level) {}
		inline void operator()(DisplayListOp* operation, int saveCount) {
		operation->defer(mDeferStruct, saveCount, mLevel, mMultipliedAlpha);
		operation->defer(mDeferStruct, saveCount, mLevel);
		}
		private:
		DeferStateStruct& mDeferStruct;
		const int mMultipliedAlpha;
		const int mLevel;
		};

		void DisplayList::defer(DeferStateStruct& deferStruct, const int level) {
		DeferOperationHandler handler(deferStruct, mCaching ? mMultipliedAlpha : -1, level);
		DeferOperationHandler handler(deferStruct, level);
		iterate<DeferOperationHandler>(deferStruct.mRenderer, handler, level);
		}

		class ReplayOperationHandler {
		public:
		ReplayOperationHandler(ReplayStateStruct& replayStruct, int multipliedAlpha, int level)
		: mReplayStruct(replayStruct), mMultipliedAlpha(multipliedAlpha), mLevel(level) {}
		ReplayOperationHandler(ReplayStateStruct& replayStruct, int level)
		: mReplayStruct(replayStruct), mLevel(level) {}
		inline void operator()(DisplayListOp* operation, int saveCount) {
		#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS
		replayStruct.mRenderer.eventMark(operation->name());
		#endif
		operation->replay(mReplayStruct, saveCount, mLevel, mMultipliedAlpha);
		operation->replay(mReplayStruct, saveCount, mLevel);
		}
		private:
		ReplayStateStruct& mReplayStruct;
		const int mMultipliedAlpha;
		const int mLevel;
		};

		void DisplayList::replay(ReplayStateStruct& replayStruct, const int level) {
		ReplayOperationHandler handler(replayStruct, mCaching ? mMultipliedAlpha : -1, level);
		ReplayOperationHandler handler(replayStruct, level);

		replayStruct.mRenderer.startMark(mName.string());
		iterate<ReplayOperationHandler>(replayStruct.mRenderer, handler, level);

libs/hwui/DisplayList.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -164,7 +164,6 @@ public:
		alpha = fminf(1.0f, fmaxf(0.0f, alpha));
		if (alpha != mAlpha) {
		mAlpha = alpha;
		mMultipliedAlpha = (int) (255 * alpha);
		}
		}

		@@ -501,7 +500,6 @@ private:
		// View properties
		bool mClipChildren;
		float mAlpha;
		int mMultipliedAlpha;
		bool mHasOverlappingRendering;
		float mTranslationX, mTranslationY;
		float mRotation, mRotationX, mRotationY;

libs/hwui/DisplayListOp.h

+46 −97

Original line number	Diff line number	Diff line
		@@ -78,11 +78,9 @@ public:
		kOpLogFlag_JSON = 0x2 // TODO: add?
		};

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) = 0;
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) = 0;

		virtual void replay(ReplayStateStruct& replayStruct, int saveCount,
		int level, int multipliedAlpha) = 0;
		virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level) = 0;

		virtual void output(int level, uint32_t logFlags = 0) = 0;

		@@ -106,8 +104,7 @@ public:

		virtual ~StateOp() {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		// default behavior only affects immediate, deferrable state, issue directly to renderer
		applyState(deferStruct.mRenderer, saveCount);
		}
		@@ -116,8 +113,7 @@ public:
		* State operations are applied directly to the renderer, but can cause the deferred drawing op
		* list to flush
		*/
		virtual void replay(ReplayStateStruct& replayStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level) {
		applyState(replayStruct.mRenderer, saveCount);
		}

		@@ -129,14 +125,12 @@ public:
		DrawOp(SkPaint* paint)
		: mPaint(paint), mQuickRejected(false) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		if (mQuickRejected &&
		CC_LIKELY(deferStruct.mReplayFlags & DisplayList::kReplayFlag_ClipChildren)) {
		return;
		}

		state.mMultipliedAlpha = multipliedAlpha;
		if (!getLocalBounds(state.mBounds)) {
		// empty bounds signify bounds can't be calculated
		state.mBounds.setEmpty();
		@@ -145,19 +139,16 @@ public:
		deferStruct.mDeferredList.addDrawOp(deferStruct.mRenderer, this);
		}

		virtual void replay(ReplayStateStruct& replayStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level) {
		if (mQuickRejected &&
		CC_LIKELY(replayStruct.mReplayFlags & DisplayList::kReplayFlag_ClipChildren)) {
		return;
		}

		replayStruct.mDrawGlStatus \|= applyDraw(replayStruct.mRenderer, replayStruct.mDirty,
		level, multipliedAlpha);
		replayStruct.mDrawGlStatus \|= applyDraw(replayStruct.mRenderer, replayStruct.mDirty, level);
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) = 0;
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) = 0;

		virtual void onDrawOpDeferred(OpenGLRenderer& renderer) {
		}
		@@ -177,8 +168,8 @@ public:
		float strokeWidthOutset() { return mPaint->getStrokeWidth() * 0.5f; }

		protected:
		SkPaint* getPaint(OpenGLRenderer& renderer, bool alwaysCopy = false) {
		return renderer.filterPaint(mPaint, alwaysCopy);
		SkPaint* getPaint(OpenGLRenderer& renderer) {
		return renderer.filterPaint(mPaint);
		}

		SkPaint* mPaint; // should be accessed via getPaint() when applying
		@@ -227,8 +218,7 @@ public:
		SaveOp(int flags)
		: mFlags(flags) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		int newSaveCount = deferStruct.mRenderer.save(mFlags);
		deferStruct.mDeferredList.addSave(deferStruct.mRenderer, this, newSaveCount);
		}
		@@ -260,8 +250,7 @@ public:
		RestoreToCountOp(int count)
		: mCount(count) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		deferStruct.mDeferredList.addRestoreToCount(deferStruct.mRenderer, saveCount + mCount);
		deferStruct.mRenderer.restoreToCount(saveCount + mCount);
		}
		@@ -293,8 +282,7 @@ public:
		int alpha, SkXfermode::Mode mode, int flags)
		: mArea(left, top, right, bottom), mAlpha(alpha), mMode(mode), mFlags(flags) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		// NOTE: don't bother with actual saveLayer, instead issuing it at flush time
		int newSaveCount = deferStruct.mRenderer.save(mFlags);
		deferStruct.mDeferredList.addSaveLayer(deferStruct.mRenderer, this, newSaveCount);
		@@ -453,8 +441,7 @@ class ClipOp : public StateOp {
		public:
		ClipOp(SkRegion::Op op) : mOp(op) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		// NOTE: must defer op BEFORE applying state, since it may read clip
		deferStruct.mDeferredList.addClip(deferStruct.mRenderer, this);

		@@ -689,16 +676,9 @@ public:
		paint),
		mBitmap(bitmap) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		bool makeCopy = multipliedAlpha >= 0 && multipliedAlpha < 255;
		SkPaint* paint = getPaint(renderer, makeCopy);
		if (makeCopy) {
		// The paint is safe to modify since we're working on a copy
		paint->setAlpha(multipliedAlpha);
		}
		status_t ret = renderer.drawBitmap(mBitmap, mLocalBounds.left, mLocalBounds.top, paint);
		return ret;
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawBitmap(mBitmap, mLocalBounds.left, mLocalBounds.top,
		getPaint(renderer));
		}

		virtual void output(int level, uint32_t logFlags) {
		@@ -723,8 +703,7 @@ public:
		transform.mapRect(mLocalBounds);
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawBitmap(mBitmap, mMatrix, getPaint(renderer));
		}

		@@ -749,8 +728,7 @@ public:
		: DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint),
		mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
		mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
		getPaint(renderer));
		@@ -776,8 +754,7 @@ public:
		DrawBitmapDataOp(SkBitmap* bitmap, float left, float top, SkPaint* paint)
		: DrawBitmapOp(bitmap, left, top, paint) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawBitmapData(mBitmap, mLocalBounds.left,
		mLocalBounds.top, getPaint(renderer));
		}
		@@ -800,8 +777,7 @@ public:
		mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight),
		mVertices(vertices), mColors(colors) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
		mVertices, mColors, getPaint(renderer));
		}
		@@ -834,8 +810,7 @@ public:
		mColors(colors), mxDivsCount(width), myDivsCount(height),
		mNumColors(numColors), mAlpha(alpha), mMode(mode) {};

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		// NOTE: not calling the virtual method, which takes a paint
		return renderer.drawPatch(mBitmap, mxDivs, myDivs, mColors,
		mxDivsCount, myDivsCount, mNumColors,
		@@ -869,8 +844,7 @@ public:
		DrawColorOp(int color, SkXfermode::Mode mode)
		: DrawOp(0), mColor(color), mMode(mode) {};

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawColor(mColor, mMode);
		}

		@@ -913,8 +887,7 @@ public:
		DrawRectOp(float left, float top, float right, float bottom, SkPaint* paint)
		: DrawStrokableOp(left, top, right, bottom, paint) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
		mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
		}
		@@ -932,8 +905,7 @@ public:
		: DrawBoundedOp(rects, count, paint),
		mRects(rects), mCount(count) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawRects(mRects, mCount, getPaint(renderer));
		}

		@@ -958,8 +930,7 @@ public:
		float rx, float ry, SkPaint* paint)
		: DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
		mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, getPaint(renderer));
		}
		@@ -981,8 +952,7 @@ public:
		: DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint),
		mX(x), mY(y), mRadius(radius) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawCircle(mX, mY, mRadius, getPaint(renderer));
		}

		@@ -1003,8 +973,7 @@ public:
		DrawOvalOp(float left, float top, float right, float bottom, SkPaint* paint)
		: DrawStrokableOp(left, top, right, bottom, paint) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
		mLocalBounds.right, mLocalBounds.bottom, getPaint(renderer));
		}
		@@ -1023,8 +992,7 @@ public:
		: DrawStrokableOp(left, top, right, bottom, paint),
		mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
		mLocalBounds.right, mLocalBounds.bottom,
		mStartAngle, mSweepAngle, mUseCenter, getPaint(renderer));
		@@ -1055,8 +1023,7 @@ public:
		mLocalBounds.set(left, top, left + width, top + height);
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawPath(mPath, getPaint(renderer));
		}

		@@ -1086,8 +1053,7 @@ public:
		mLocalBounds.outset(strokeWidthOutset());
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawLines(mPoints, mCount, getPaint(renderer));
		}

		@@ -1113,8 +1079,7 @@ public:
		DrawPointsOp(float* points, int count, SkPaint* paint)
		: DrawLinesOp(points, count, paint) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawPoints(mPoints, mCount, getPaint(renderer));
		}

		@@ -1160,8 +1125,7 @@ public:
		/* TODO: inherit from DrawBounded and init mLocalBounds */
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
		mHOffset, mVOffset, getPaint(renderer));
		}
		@@ -1182,8 +1146,7 @@ public:
		/* TODO: inherit from DrawBounded and init mLocalBounds */
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawPosText(mText, mBytesCount, mCount, mPositions, getPaint(renderer));
		}

		@@ -1231,8 +1194,7 @@ public:
		}
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawText(mText, mBytesCount, mCount, mX, mY,
		mPositions, getPaint(renderer), mLength);
		}
		@@ -1269,8 +1231,7 @@ public:
		DrawFunctorOp(Functor* functor)
		: DrawOp(0), mFunctor(functor) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		renderer.startMark("GL functor");
		status_t ret = renderer.callDrawGLFunction(mFunctor, dirty);
		renderer.endMark();
		@@ -1293,22 +1254,21 @@ public:
		: DrawBoundedOp(0, 0, displayList->getWidth(), displayList->getHeight(), 0),
		mDisplayList(displayList), mFlags(flags) {}

		virtual void defer(DeferStateStruct& deferStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level) {
		if (mDisplayList && mDisplayList->isRenderable()) {
		mDisplayList->defer(deferStruct, level + 1);
		}
		}

		virtual void replay(ReplayStateStruct& replayStruct, int saveCount,
		int level, int multipliedAlpha) {
		virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level) {
		if (mDisplayList && mDisplayList->isRenderable()) {
		mDisplayList->replay(replayStruct, level + 1);
		}
		}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) { return DrawGlInfo::kStatusDone; }
		// NOT USED since replay() is overridden
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return DrawGlInfo::kStatusDone;
		}

		virtual void output(int level, uint32_t logFlags) {
		OP_LOG("Draw Display List %p, flags %#x", mDisplayList, mFlags);
		@@ -1326,22 +1286,11 @@ private:

		class DrawLayerOp : public DrawOp {
		public:
		DrawLayerOp(Layer* layer, float x, float y, SkPaint* paint)
		: DrawOp(paint), mLayer(layer), mX(x), mY(y) {}
		DrawLayerOp(Layer* layer, float x, float y)
		: DrawOp(0), mLayer(layer), mX(x), mY(y) {}

		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level,
		int multipliedAlpha) {
		int oldAlpha = -1;

		if (multipliedAlpha >= 0 && multipliedAlpha < 255) {
		oldAlpha = mLayer->getAlpha();
		mLayer->setAlpha(multipliedAlpha);
		}
		status_t ret = renderer.drawLayer(mLayer, mX, mY, getPaint(renderer));
		if (oldAlpha >= 0) {
		mLayer->setAlpha(oldAlpha);
		}
		return ret;
		virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty, int level) {
		return renderer.drawLayer(mLayer, mX, mY);
		}

		virtual void output(int level, uint32_t logFlags) {