Merge "Add internal Canvas save flags" (dd93728b) · Commits · e / os / android_frameworks_base

core/jni/android_graphics_Canvas.cpp

+5 −5

Original line number	Diff line number	Diff line
		@@ -86,20 +86,20 @@ static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) {
		}

		static jint save(JNIEnv*, jobject, jlong canvasHandle, jint flagsHandle) {
		SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
		SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
		return static_cast<jint>(get_canvas(canvasHandle)->save(flags));
		}

		static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,
		jfloat r, jfloat b, jlong paintHandle, jint flagsHandle) {
		Paint* paint = reinterpret_cast<Paint*>(paintHandle);
		SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
		SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
		return static_cast<jint>(get_canvas(canvasHandle)->saveLayer(l, t, r, b, paint, flags));
		}

		static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,
		jfloat r, jfloat b, jint alpha, jint flagsHandle) {
		SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
		SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
		return static_cast<jint>(get_canvas(canvasHandle)->saveLayerAlpha(l, t, r, b, alpha, flags));
		}

		@@ -351,7 +351,7 @@ static void drawNinePatch(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmap
		if (CC_LIKELY(dstDensity == srcDensity \|\| dstDensity == 0 \|\| srcDensity == 0)) {
		canvas->drawNinePatch(skiaBitmap, *chunk, left, top, right, bottom, paint);
		} else {
		canvas->save(SkCanvas::kMatrixClip_SaveFlag);
		canvas->save(SaveFlags::MatrixClip);

		SkScalar scale = dstDensity / (float)srcDensity;
		canvas->translate(left, top);
		@@ -390,7 +390,7 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject
		canvas->drawBitmap(bitmap, left, top, paint);
		}
		} else {
		canvas->save(SkCanvas::kMatrixClip_SaveFlag);
		canvas->save(SaveFlags::MatrixClip);
		SkScalar scale = canvasDensity / (float)bitmapDensity;
		canvas->translate(left, top);
		canvas->scale(scale, scale);

libs/hwui/Canvas.h

+20 −3

Original line number	Diff line number	Diff line
		@@ -27,6 +27,22 @@

		namespace android {

		namespace SaveFlags {

		// These must match the corresponding Canvas API constants.
		enum {
		Matrix = 0x01,
		Clip = 0x02,
		HasAlphaLayer = 0x04,
		ClipToLayer = 0x10,

		// Helper constant
		MatrixClip = Matrix \| Clip,
		};
		typedef uint32_t Flags;

		} // namespace SaveFlags

		class ANDROID_API Canvas {
		public:
		virtual ~Canvas() {};
		@@ -70,16 +86,17 @@ public:
		// ----------------------------------------------------------------------------
		// Canvas state operations
		// ----------------------------------------------------------------------------

		// Save (layer)
		virtual int getSaveCount() const = 0;
		virtual int save(SkCanvas::SaveFlags flags) = 0;
		virtual int save(SaveFlags::Flags flags) = 0;
		virtual void restore() = 0;
		virtual void restoreToCount(int saveCount) = 0;

		virtual int saveLayer(float left, float top, float right, float bottom,
		const SkPaint* paint, SkCanvas::SaveFlags flags) = 0;
		const SkPaint* paint, SaveFlags::Flags flags) = 0;
		virtual int saveLayerAlpha(float left, float top, float right, float bottom,
		int alpha, SkCanvas::SaveFlags flags) = 0;
		int alpha, SaveFlags::Flags flags) = 0;

		// Matrix
		virtual void getMatrix(SkMatrix* outMatrix) const = 0;

libs/hwui/CanvasState.cpp

+3 −6

Original line number	Diff line number	Diff line
		@@ -14,8 +14,7 @@
		* limitations under the License.
		*/

		#include <SkCanvas.h>

		#include "Canvas.h"
		#include "CanvasState.h"
		#include "utils/MathUtils.h"

		@@ -54,8 +53,7 @@ void CanvasState::initializeRecordingSaveStack(int viewportWidth, int viewportHe
		}

		freeAllSnapshots();
		mSnapshot = allocSnapshot(&mFirstSnapshot,
		SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);
		mSnapshot = allocSnapshot(&mFirstSnapshot, SaveFlags::MatrixClip);
		mSnapshot->setRelativeLightCenter(Vector3());
		mSaveCount = 1;
		}
		@@ -72,8 +70,7 @@ void CanvasState::initializeSaveStack(
		}

		freeAllSnapshots();
		mSnapshot = allocSnapshot(&mFirstSnapshot,
		SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);
		mSnapshot = allocSnapshot(&mFirstSnapshot, SaveFlags::MatrixClip);
		mSnapshot->setClip(clipLeft, clipTop, clipRight, clipBottom);
		mSnapshot->fbo = mCanvas.getTargetFbo();
		mSnapshot->setRelativeLightCenter(lightCenter);

libs/hwui/DeferredDisplayList.cpp

+4 −6

Original line number	Diff line number	Diff line
		@@ -14,8 +14,6 @@
		* limitations under the License.
		*/

		#include <SkCanvas.h>

		#include <utils/Trace.h>
		#include <ui/Rect.h>
		#include <ui/Region.h>
		@@ -419,7 +417,7 @@ void DeferredDisplayList::addClip(OpenGLRenderer& renderer, ClipOp* op) {
		* beginning of the frame. This would avoid targetting and removing an FBO in the middle of a frame.
		*
		* saveLayer operations should be pulled to the beginning of the frame if the canvas doesn't have a
		* complex clip, and if the flags (kClip_SaveFlag & kClipToLayer_SaveFlag) are set.
		* complex clip, and if the flags (SaveFlags::Clip & SaveFlags::ClipToLayer) are set.
		*/
		void DeferredDisplayList::addSaveLayer(OpenGLRenderer& renderer,
		SaveLayerOp* op, int newSaveCount) {
		@@ -438,7 +436,7 @@ void DeferredDisplayList::addSave(OpenGLRenderer& renderer, SaveOp* op, int newS
		int saveFlags = op->getFlags();
		DEFER_LOGD("%p adding saveOp %p, flags %x, new count %d", this, op, saveFlags, newSaveCount);

		if (recordingComplexClip() && (saveFlags & SkCanvas::kClip_SaveFlag)) {
		if (recordingComplexClip() && (saveFlags & SaveFlags::Clip)) {
		// store and replay the save operation, as it may be needed to correctly playback the clip
		DEFER_LOGD(" adding save barrier with new save count %d", newSaveCount);
		storeStateOpBarrier(renderer, op);
		@@ -621,7 +619,7 @@ void DeferredDisplayList::storeRestoreToCountBarrier(OpenGLRenderer& renderer, S
		this, newSaveCount, mBatches.size());

		// store displayState for the restore operation, as it may be associated with a saveLayer that
		// doesn't have kClip_SaveFlag set
		// doesn't have SaveFlags::Clip set
		DeferredDisplayState* state = createState();
		renderer.storeDisplayState(*state, getStateOpDeferFlags());
		mBatches.push_back(new RestoreToCountBatch(op, state, newSaveCount));
		@@ -654,7 +652,7 @@ void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) {
		renderer.eventMark("Flush");

		// save and restore so that reordering doesn't affect final state
		renderer.save(SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);
		renderer.save(SaveFlags::MatrixClip);

		if (CC_LIKELY(avoidOverdraw())) {
		for (unsigned int i = 1; i < mBatches.size(); i++) {

libs/hwui/DisplayListCanvas.cpp

+7 −7

Original line number	Diff line number	Diff line
		@@ -102,7 +102,7 @@ SkCanvas* DisplayListCanvas::asSkCanvas() {
		return mSkiaCanvasProxy.get();
		}

		int DisplayListCanvas::save(SkCanvas::SaveFlags flags) {
		int DisplayListCanvas::save(SaveFlags::Flags flags) {
		addStateOp(new (alloc()) SaveOp((int) flags));
		return mState.save((int) flags);
		}
		@@ -125,9 +125,9 @@ void DisplayListCanvas::restoreToCount(int saveCount) {
		}

		int DisplayListCanvas::saveLayer(float left, float top, float right, float bottom,
		const SkPaint* paint, SkCanvas::SaveFlags flags) {
		const SkPaint* paint, SaveFlags::Flags flags) {
		// force matrix/clip isolation for layer
		flags \|= SkCanvas::kClip_SaveFlag \| SkCanvas::kMatrix_SaveFlag;
		flags \|= SaveFlags::MatrixClip;

		paint = refPaint(paint);
		addStateOp(new (alloc()) SaveLayerOp(left, top, right, bottom, paint, (int) flags));
		@@ -232,7 +232,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint)

		void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top,
		const SkPaint* paint) {
		save(SkCanvas::kMatrix_SaveFlag);
		save(SaveFlags::Matrix);
		translate(left, top);
		drawBitmap(&bitmap, paint);
		restore();
		@@ -253,7 +253,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matri
		drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,
		dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);
		} else {
		save(SkCanvas::kMatrix_SaveFlag);
		save(SaveFlags::Matrix);
		concat(matrix);
		drawBitmap(&bitmap, paint);
		restore();
		@@ -269,7 +269,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float
		&& (srcBottom - srcTop == dstBottom - dstTop)
		&& (srcRight - srcLeft == dstRight - dstLeft)) {
		// transform simple rect to rect drawing case into position bitmap ops, since they merge
		save(SkCanvas::kMatrix_SaveFlag);
		save(SaveFlags::Matrix);
		translate(dstLeft, dstTop);
		drawBitmap(&bitmap, paint);
		restore();
		@@ -283,7 +283,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float
		// Apply the scale transform on the canvas, so that the shader
		// effectively calculates positions relative to src rect space

		save(SkCanvas::kMatrix_SaveFlag);
		save(SaveFlags::Matrix);
		translate(dstLeft, dstTop);
		scale(scaleX, scaleY);