diff --git a/tests/CanvasCompare/Android.mk b/tests/CanvasCompare/Android.mk
new file mode 100644
index 0000000000000..642c9e918336d
--- /dev/null
+++ b/tests/CanvasCompare/Android.mk
@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src)
+
+LOCAL_PACKAGE_NAME := CanvasCompare
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+include $(BUILD_PACKAGE)
diff --git a/tests/CanvasCompare/AndroidManifest.xml b/tests/CanvasCompare/AndroidManifest.xml
new file mode 100644
index 0000000000000..1cb8c37a85d6e
--- /dev/null
+++ b/tests/CanvasCompare/AndroidManifest.xml
@@ -0,0 +1,47 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/CanvasCompare/res/drawable/sunset1.jpg b/tests/CanvasCompare/res/drawable/sunset1.jpg
new file mode 100644
index 0000000000000..92851f3df9249
Binary files /dev/null and b/tests/CanvasCompare/res/drawable/sunset1.jpg differ
diff --git a/tests/CanvasCompare/res/layout/automatic_layout.xml b/tests/CanvasCompare/res/layout/automatic_layout.xml
new file mode 100644
index 0000000000000..e049ec0a50007
--- /dev/null
+++ b/tests/CanvasCompare/res/layout/automatic_layout.xml
@@ -0,0 +1,38 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/CanvasCompare/res/layout/manual_layout.xml b/tests/CanvasCompare/res/layout/manual_layout.xml
new file mode 100644
index 0000000000000..1a9288ce1993c
--- /dev/null
+++ b/tests/CanvasCompare/res/layout/manual_layout.xml
@@ -0,0 +1,119 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/CanvasCompare/res/values/strings.xml b/tests/CanvasCompare/res/values/strings.xml
new file mode 100644
index 0000000000000..edd46103f4f56
--- /dev/null
+++ b/tests/CanvasCompare/res/values/strings.xml
@@ -0,0 +1,31 @@
+
+
+
+ Canvas Compare Test
+
+
+ Hardware
+
+ Software
+
+ Error
+
+ Heatmap
+
+ Next Combination
+
+ Previous Combination
+
diff --git a/tests/CanvasCompare/res/values/values.xml b/tests/CanvasCompare/res/values/values.xml
new file mode 100644
index 0000000000000..f69378d34f652
--- /dev/null
+++ b/tests/CanvasCompare/res/values/values.xml
@@ -0,0 +1,25 @@
+
+
+
+
+
+ 320px
+ 320px
+
+ 640px
+ 640px
+
+
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/AutomaticActivity.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/AutomaticActivity.java
new file mode 100644
index 0000000000000..e0ff1dc8eab80
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/AutomaticActivity.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import java.util.ArrayList;
+
+import com.android.test.hwuicompare.R;
+
+import android.os.Bundle;
+import android.os.Trace;
+import android.util.Log;
+import android.widget.ImageView;
+import android.widget.Toast;
+
+public class AutomaticActivity extends CompareActivity {
+ private static final String LOG_TAG = "AutomaticActivity";
+ private static final float ERROR_DISPLAY_THRESHOLD = 0.01f;
+ protected static final boolean DRAW_BITMAPS = false;
+
+ private ImageView mSoftwareImageView = null;
+ private ImageView mHardwareImageView = null;
+
+ private static final float[] ERROR_CUTOFFS = {0, 0.005f, 0.01f, 0.02f, 0.05f, 0.1f, 0.25f, 0.5f, 1f, 2f};
+ private float[] mErrorRates = new float[ERROR_CUTOFFS.length];
+ private float mTotalTests = 0;
+ private float mTotalError = 0;
+
+ public abstract static class TestCallback {
+ abstract void report(String name, float value);
+ void complete() {}
+ }
+
+ private ArrayList mTestCallbacks = new ArrayList();
+
+ Runnable mRunnable = new Runnable() {
+ @Override
+ public void run() {
+ loadBitmaps();
+ if (mSoftwareBitmap == null || mHardwareBitmap == null) {
+ Log.e(LOG_TAG, "bitmap is null");
+ return;
+ }
+
+ if (DRAW_BITMAPS) {
+ mSoftwareImageView.setImageBitmap(mSoftwareBitmap);
+ mHardwareImageView.setImageBitmap(mHardwareBitmap);
+ }
+
+ Trace.traceBegin(Trace.TRACE_TAG_ALWAYS, "calculateError");
+ float error = mErrorCalculator.calcErrorRS(mSoftwareBitmap, mHardwareBitmap);
+ Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
+
+ if (error > ERROR_DISPLAY_THRESHOLD) {
+ String modname = "";
+ for (String s : DisplayModifier.getLastAppliedModifications()) {
+ modname = modname.concat(s + ".");
+ }
+ Log.d(LOG_TAG, String.format("error for %s was %2.9f", modname, error));
+ }
+ for (int i = 0; i < ERROR_CUTOFFS.length; i++) {
+ if (error <= ERROR_CUTOFFS[i]) break;
+ mErrorRates[i]++;
+ }
+ mTotalError += error;
+ mTotalTests++;
+
+ if (DisplayModifier.step()) {
+ for (TestCallback c : mTestCallbacks) {
+ c.report("averageError", (mTotalError / mTotalTests));
+ for (int i = 1; i < ERROR_CUTOFFS.length; i++) {
+ c.report(String.format("error over %1.3f", ERROR_CUTOFFS[i]),
+ mErrorRates[i]/mTotalTests);
+ }
+ c.complete();
+ }
+
+ Toast.makeText(getApplicationContext(), "done!", Toast.LENGTH_SHORT).show();
+ finish();
+ } else {
+ mHardwareView.invalidate();
+ if (DRAW_BITMAPS) {
+ mSoftwareImageView.invalidate();
+ mHardwareImageView.invalidate();
+ }
+ }
+ mHandler.removeCallbacks(mRunnable);
+ }
+ };
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+ mHandler.removeCallbacks(mRunnable);
+ };
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.automatic_layout);
+
+ mSoftwareImageView = (ImageView) findViewById(R.id.software_image_view);
+ mHardwareImageView = (ImageView) findViewById(R.id.hardware_image_view);
+
+ onCreateCommon(mRunnable);
+ mTestCallbacks.add(new TestCallback() {
+ void report(String name, float value) {
+ Log.d(LOG_TAG, name + " " + value);
+ };
+ });
+ }
+
+ @Override
+ protected boolean forceRecreateBitmaps() {
+ // disable, unless needed for drawing into imageviews
+ return DRAW_BITMAPS;
+ }
+
+ // FOR TESTING
+ public void setCallback(TestCallback c) {
+ mTestCallbacks.add(c);
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/CompareActivity.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/CompareActivity.java
new file mode 100644
index 0000000000000..0b85189d9d9ba
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/CompareActivity.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import com.android.test.hwuicompare.R;
+
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.os.Handler;
+import android.os.Trace;
+import android.util.Log;
+import android.view.View;
+
+abstract public class CompareActivity extends Activity {
+ private static final String LOG_TAG = "CompareActivity";
+
+ protected MainView mHardwareView = null;
+
+ protected Bitmap mSoftwareBitmap;
+ protected Bitmap mHardwareBitmap;
+
+ protected ErrorCalculator mErrorCalculator;
+
+ protected Handler mHandler;
+
+ Runnable mDrawCallback = null;
+ protected boolean mRedrewFlag = true;
+
+ protected void onCreateCommon(final Runnable postDrawCallback) {
+ mDrawCallback = new Runnable() {
+ @Override
+ public void run() {
+ mRedrewFlag = true;
+ mHandler.post(postDrawCallback);
+ };
+ };
+ getWindow().setBackgroundDrawable(new ColorDrawable(0xffefefef));
+ ResourceModifiers.init(getResources());
+
+ mHardwareView = (MainView) findViewById(R.id.hardware_view);
+ mHardwareView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+ mHardwareView.setBackgroundColor(Color.WHITE);
+ mHardwareView.addDrawCallback(mDrawCallback);
+
+ int width = getResources().getDimensionPixelSize(R.dimen.layer_width);
+ int height = getResources().getDimensionPixelSize(R.dimen.layer_height);
+ mSoftwareBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ mHardwareBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+
+ mErrorCalculator = new ErrorCalculator(getApplicationContext(), getResources());
+
+ mHandler = new Handler();
+ }
+
+ protected abstract boolean forceRecreateBitmaps();
+
+ protected void loadBitmaps() {
+ Trace.traceBegin(Trace.TRACE_TAG_ALWAYS, "loadBitmaps");
+ if (forceRecreateBitmaps()) {
+ int width = mSoftwareBitmap.getWidth();
+ int height = mSoftwareBitmap.getHeight();
+
+ mSoftwareBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ mHardwareBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ }
+
+ Trace.traceBegin(Trace.TRACE_TAG_ALWAYS, "softwareDraw");
+ mHardwareView.draw(new Canvas(mSoftwareBitmap));
+ Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
+
+ try {
+ Method getHardwareLayer = View.class.getDeclaredMethod("getHardwareLayer");
+ if (!getHardwareLayer.isAccessible())
+ getHardwareLayer.setAccessible(true);
+ Object hardwareLayer = getHardwareLayer.invoke(mHardwareView);
+ if (hardwareLayer == null) {
+ Log.d(LOG_TAG, "failure to access hardware layer");
+ return;
+ }
+ Method copyInto = hardwareLayer.getClass().getSuperclass()
+ .getDeclaredMethod("copyInto", Bitmap.class);
+ if (!copyInto.isAccessible())
+ copyInto.setAccessible(true);
+
+ Trace.traceBegin(Trace.TRACE_TAG_ALWAYS, "copyInto");
+ boolean success = (Boolean) copyInto.invoke(hardwareLayer, mHardwareBitmap);
+ Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
+ if (!success) {
+ Log.d(LOG_TAG, "failure to copy hardware layer into bitmap");
+ }
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ } catch (IllegalArgumentException e) {
+ e.printStackTrace();
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ } catch (InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java
new file mode 100644
index 0000000000000..602214128b4e7
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java
@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.RectF;
+import android.util.Log;
+
+public abstract class DisplayModifier {
+
+ // automated tests ignore any combination of operations that don't together return TOTAL_MASK
+ protected final static int TOTAL_MASK = 0x1F;
+
+ // if we're filling, ensure we're not also sweeping over stroke parameters
+ protected final static int SWEEP_STROKE_WIDTH_BIT = 0x1 << 0;
+ protected final static int SWEEP_STROKE_CAP_BIT = 0x1 << 1;
+ protected final static int SWEEP_STROKE_JOIN_BIT = 0x1 << 2;
+
+ protected final static int SWEEP_SHADER_BIT = 0x1 << 3; // only allow non-simple shaders to use rectangle drawing
+ protected final static int SWEEP_TRANSFORM_BIT = 0x1 << 4; // only sweep over specified transforms
+
+ abstract public void modifyDrawing(Paint paint, Canvas canvas);
+ protected int mask() { return 0x0; };
+
+ private static final RectF gRect = new RectF(0, 0, 200, 175);
+ private static final float[] gLinePts = new float[] {
+ 100, 0, 200, 200, 200, 200, 0, 200, 0, 200, 100, 0
+ };
+ private static final float[] gPts = new float[] {
+ 0, 100, 100, 0, 100, 200, 200, 100
+ };
+
+ @SuppressWarnings("serial")
+ private static final LinkedHashMap> gMaps = new LinkedHashMap>() {
+ {
+ put("aa", new LinkedHashMap() {
+ {
+ put("true", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setAntiAlias(true);
+ }
+ });
+ put("false", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setAntiAlias(false);
+ }
+ });
+ }
+ });
+ put("style", new LinkedHashMap() {
+ {
+ put("fill", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStyle(Paint.Style.FILL);
+ }
+ });
+ put("stroke", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStyle(Paint.Style.STROKE);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+ });
+ put("fillAndStroke", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStyle(Paint.Style.FILL_AND_STROKE);
+ }
+
+ @Override
+ protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+ });
+ }
+ });
+ put("strokeWidth", new LinkedHashMap() {
+ {
+ put("hair", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeWidth(0);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+ });
+ put("0.3", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeWidth(0.3f);
+ }
+ });
+ put("1", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeWidth(1);
+ }
+ });
+ put("5", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeWidth(5);
+ }
+ });
+ }
+ });
+ put("strokeCap", new LinkedHashMap() {
+ {
+ put("butt", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeCap(Paint.Cap.BUTT);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_CAP_BIT; }
+ });
+ put("round", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeCap(Paint.Cap.ROUND);
+ }
+ });
+ put("square", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeCap(Paint.Cap.SQUARE);
+ }
+ });
+ }
+ });
+ put("strokeJoin", new LinkedHashMap() {
+ {
+ put("bevel", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeJoin(Paint.Join.BEVEL);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_JOIN_BIT; }
+ });
+ put("round", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeJoin(Paint.Join.ROUND);
+ }
+ });
+ put("miter", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setStrokeJoin(Paint.Join.MITER);
+ }
+ });
+ // TODO: add miter0, miter1 etc to test miter distances
+ }
+ });
+
+ put("transform", new LinkedHashMap() {
+ {
+ put("noTransform", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {}
+ @Override
+ protected int mask() { return SWEEP_TRANSFORM_BIT; };
+ });
+ put("rotate5", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.rotate(5);
+ }
+ });
+ put("rotate45", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.rotate(5);
+ }
+ });
+ put("rotate90", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.rotate(90);
+ canvas.translate(0, -200);
+ }
+ });
+ put("scale2x2", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.scale(2, 2);
+ }
+ @Override
+ protected int mask() { return SWEEP_TRANSFORM_BIT; };
+ });
+ put("rot20scl1x4", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.rotate(20);
+ canvas.scale(1, 4);
+ }
+ @Override
+ protected int mask() { return SWEEP_TRANSFORM_BIT; };
+ });
+ }
+ });
+
+ put("shader", new LinkedHashMap() {
+ {
+ put("noShader", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {}
+ @Override
+ protected int mask() { return SWEEP_SHADER_BIT; };
+ });
+ put("repeatShader", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mRepeatShader);
+ }
+ @Override
+ protected int mask() { return SWEEP_SHADER_BIT; };
+ });
+ put("translatedShader", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mTranslatedShader);
+ }
+ });
+ put("scaledShader", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mScaledShader);
+ }
+ });
+ put("horGradient", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mHorGradient);
+ }
+ });
+ put("diagGradient", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mDiagGradient);
+ }
+ @Override
+ protected int mask() { return SWEEP_SHADER_BIT; };
+ });
+ put("vertGradient", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setShader(ResourceModifiers.instance().mVertGradient);
+ }
+ });
+ }
+ });
+
+ // FINAL MAP: DOES ACTUAL DRAWING
+ put("drawing", new LinkedHashMap() {
+ {
+ put("roundRect", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawRoundRect(gRect, 20, 20, paint);
+ }
+ });
+ put("rect", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawRect(gRect, paint);
+ }
+ @Override
+ protected int mask() { return SWEEP_SHADER_BIT | SWEEP_STROKE_CAP_BIT; };
+ });
+ put("circle", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawCircle(100, 100, 75, paint);
+ }
+ });
+ put("oval", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawOval(gRect, paint);
+ }
+ });
+ put("triLines", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawLines(gLinePts, paint);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_CAP_BIT; };
+ });
+ put("plusPoints", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawPoints(gPts, paint);
+ }
+ });
+ put("text", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setTextSize(36);
+ canvas.drawText("TEXTTEST", 0, 50, paint);
+ }
+ });
+ put("shadowtext", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ paint.setTextSize(36);
+ paint.setShadowLayer(3.0f, 0.0f, 3.0f, 0xffff00ff);
+ canvas.drawText("TEXTTEST", 0, 50, paint);
+ }
+ });
+ put("bitmapMesh", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawBitmapMesh(ResourceModifiers.instance().mBitmap, 3, 3,
+ ResourceModifiers.instance().mBitmapVertices, 0, null, 0, null);
+ }
+ });
+ put("arc", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawArc(gRect, 260, 285, false, paint);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_CAP_BIT; };
+ });
+ put("arcFromCenter", new DisplayModifier() {
+ @Override
+ public void modifyDrawing(Paint paint, Canvas canvas) {
+ canvas.drawArc(gRect, 260, 285, true, paint);
+ }
+ @Override
+ protected int mask() { return SWEEP_STROKE_JOIN_BIT; };
+ });
+ }
+ });
+ // WARNING: DON'T PUT MORE MAPS BELOW THIS
+ }
+ };
+
+ private static LinkedHashMap getMapAtIndex(int index) {
+ for (LinkedHashMap map : gMaps.values()) {
+ if (index == 0) {
+ return map;
+ }
+ index--;
+ }
+ return null;
+ }
+
+ // indices instead of iterators for easier bidirectional traversal
+ private static final int mIndices[] = new int[gMaps.size()];
+ private static final String[] mLastAppliedModifications = new String[gMaps.size()];
+
+ private static boolean stepInternal(boolean forward) {
+ int modifierMapIndex = gMaps.size() - 1;
+ while (modifierMapIndex >= 0) {
+ LinkedHashMap map = getMapAtIndex(modifierMapIndex);
+ mIndices[modifierMapIndex] += (forward ? 1 : -1);
+
+ if (mIndices[modifierMapIndex] >= 0 && mIndices[modifierMapIndex] < map.size()) {
+ break;
+ }
+
+ mIndices[modifierMapIndex] = (forward ? 0 : map.size() - 1);
+ modifierMapIndex--;
+ }
+ return modifierMapIndex < 0; // true if resetting
+ }
+
+ public static boolean step() {
+ boolean ret = false;
+ do {
+ ret |= stepInternal(true);
+ } while (!checkModificationStateMask());
+ return ret;
+ }
+
+ public static boolean stepBack() {
+ boolean ret = false;
+ do {
+ ret |= stepInternal(false);
+ } while (!checkModificationStateMask());
+ return ret;
+ }
+
+ private static boolean checkModificationStateMask() {
+ int operatorMask = 0x0;
+ int mapIndex = 0;
+ for (LinkedHashMap map : gMaps.values()) {
+ int displayModifierIndex = mIndices[mapIndex];
+ for (Entry modifierEntry : map.entrySet()) {
+ if (displayModifierIndex == 0) {
+ mLastAppliedModifications[mapIndex] = modifierEntry.getKey();
+ operatorMask |= modifierEntry.getValue().mask();
+ break;
+ }
+ displayModifierIndex--;
+ }
+ mapIndex++;
+ }
+ return operatorMask == TOTAL_MASK;
+ }
+
+ public static void apply(Paint paint, Canvas canvas) {
+ int mapIndex = 0;
+ for (LinkedHashMap map : gMaps.values()) {
+ int displayModifierIndex = mIndices[mapIndex];
+ for (Entry modifierEntry : map.entrySet()) {
+ if (displayModifierIndex == 0) {
+ mLastAppliedModifications[mapIndex] = modifierEntry.getKey();
+ modifierEntry.getValue().modifyDrawing(paint, canvas);
+ break;
+ }
+ displayModifierIndex--;
+ }
+ mapIndex++;
+ }
+ }
+
+ public static String[] getLastAppliedModifications() {
+ return mLastAppliedModifications.clone();
+ }
+
+ public static String[][] getStrings() {
+ String[][] keys = new String[gMaps.size()][];
+
+ int i = 0;
+ for (LinkedHashMap map : gMaps.values()) {
+ keys[i] = new String[map.size()];
+ int j = 0;
+ for (String key : map.keySet()) {
+ keys[i][j++] = key;
+ }
+ i++;
+ }
+
+ return keys;
+ }
+
+ public static void setIndex(int mapIndex, int newIndexValue) {
+ mIndices[mapIndex] = newIndexValue;
+ }
+
+ public static int[] getIndices() {
+ return mIndices;
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/ErrorCalculator.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/ErrorCalculator.java
new file mode 100644
index 0000000000000..a08b558fee1ff
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/ErrorCalculator.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import com.android.test.hwuicompare.R;
+import com.android.test.hwuicompare.ScriptC_errorCalculator;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.util.Log;
+
+public class ErrorCalculator {
+ private static final String LOG_TAG = "ErrorCalculator";
+ private static final int REGION_SIZE = 8;
+
+ private static final boolean LOG_TIMING = false;
+ private static final boolean LOG_CALC = false;
+
+ private final RenderScript mRS;
+ private Allocation mIdealPixelsAllocation;
+ private Allocation mGivenPixelsAllocation;
+ private Allocation mOutputPixelsAllocation;
+
+ private final Allocation mInputRowsAllocation;
+ private final Allocation mOutputRegionsAllocation;
+
+ private final ScriptC_errorCalculator mScript;
+
+ private final int[] mOutputRowRegions;
+
+ public ErrorCalculator(Context c, Resources resources) {
+ int width = resources.getDimensionPixelSize(R.dimen.layer_width);
+ int height = resources.getDimensionPixelSize(R.dimen.layer_height);
+ mOutputRowRegions = new int[height / REGION_SIZE];
+
+ mRS = RenderScript.create(c);
+ int[] rowIndices = new int[height / REGION_SIZE];
+ for (int i = 0; i < rowIndices.length; i++)
+ rowIndices[i] = i * REGION_SIZE;
+
+ mScript = new ScriptC_errorCalculator(mRS, resources, R.raw.errorcalculator);
+ mScript.set_HEIGHT(height);
+ mScript.set_WIDTH(width);
+ mScript.set_REGION_SIZE(REGION_SIZE);
+
+ mInputRowsAllocation = Allocation.createSized(mRS, Element.I32(mRS), rowIndices.length,
+ Allocation.USAGE_SCRIPT);
+ mInputRowsAllocation.copyFrom(rowIndices);
+ mOutputRegionsAllocation = Allocation.createSized(mRS, Element.I32(mRS),
+ mOutputRowRegions.length, Allocation.USAGE_SCRIPT);
+ }
+
+
+ private static long startMillis, middleMillis;
+
+ public float calcErrorRS(Bitmap ideal, Bitmap given) {
+ if (LOG_TIMING) {
+ startMillis = System.currentTimeMillis();
+ }
+
+ mIdealPixelsAllocation = Allocation.createFromBitmap(mRS, ideal,
+ Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+ mGivenPixelsAllocation = Allocation.createFromBitmap(mRS, given,
+ Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+
+ mScript.bind_ideal(mIdealPixelsAllocation);
+ mScript.bind_given(mGivenPixelsAllocation);
+
+ mScript.forEach_countInterestingRegions(mInputRowsAllocation, mOutputRegionsAllocation);
+ mOutputRegionsAllocation.copyTo(mOutputRowRegions);
+
+ int regionCount = 0;
+ for (int region : mOutputRowRegions) {
+ regionCount += region;
+ }
+ int interestingPixels = Math.max(1, regionCount) * REGION_SIZE * REGION_SIZE;
+
+ if (LOG_TIMING) {
+ long startMillis2 = System.currentTimeMillis();
+ }
+
+ mScript.forEach_accumulateError(mInputRowsAllocation, mOutputRegionsAllocation);
+ mOutputRegionsAllocation.copyTo(mOutputRowRegions);
+ float totalError = 0;
+ for (int row : mOutputRowRegions) {
+ totalError += row;
+ }
+ totalError /= 1024.0f;
+
+ if (LOG_TIMING) {
+ long finalMillis = System.currentTimeMillis();
+ Log.d(LOG_TAG, "rs: first part took " + (middleMillis - startMillis) + "ms");
+ Log.d(LOG_TAG, "rs: last part took " + (finalMillis - middleMillis) + "ms");
+ }
+ if (LOG_CALC) {
+ Log.d(LOG_TAG, "rs: error " + totalError + ", pixels " + interestingPixels);
+ }
+ return totalError / interestingPixels;
+ }
+
+ public void calcErrorHeatmapRS(Bitmap ideal, Bitmap given, Bitmap output) {
+ mIdealPixelsAllocation = Allocation.createFromBitmap(mRS, ideal,
+ Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+ mGivenPixelsAllocation = Allocation.createFromBitmap(mRS, given,
+ Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+
+ mScript.bind_ideal(mIdealPixelsAllocation);
+ mScript.bind_given(mGivenPixelsAllocation);
+
+ mOutputPixelsAllocation = Allocation.createFromBitmap(mRS, output,
+ Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+ mScript.forEach_displayDifference(mOutputPixelsAllocation, mOutputPixelsAllocation);
+ mOutputPixelsAllocation.copyTo(output);
+ }
+
+ public static float calcError(Bitmap ideal, Bitmap given) {
+ if (LOG_TIMING) {
+ startMillis = System.currentTimeMillis();
+ }
+
+ int interestingRegions = 0;
+ for (int x = 0; x < ideal.getWidth(); x += REGION_SIZE) {
+ for (int y = 0; y < ideal.getWidth(); y += REGION_SIZE) {
+ if (inspectRegion(ideal, x, y)) {
+ interestingRegions++;
+ }
+ }
+ }
+
+ int interestingPixels = Math.max(1, interestingRegions) * REGION_SIZE * REGION_SIZE;
+
+ if (LOG_TIMING) {
+ long startMillis2 = System.currentTimeMillis();
+ }
+
+ float totalError = 0;
+ for (int x = 0; x < ideal.getWidth(); x++) {
+ for (int y = 0; y < ideal.getHeight(); y++) {
+ int idealColor = ideal.getPixel(x, y);
+ int givenColor = given.getPixel(x, y);
+ if (idealColor == givenColor)
+ continue;
+ totalError += Math.abs(Color.red(idealColor) - Color.red(givenColor));
+ totalError += Math.abs(Color.green(idealColor) - Color.green(givenColor));
+ totalError += Math.abs(Color.blue(idealColor) - Color.blue(givenColor));
+ totalError += Math.abs(Color.alpha(idealColor) - Color.alpha(givenColor));
+ }
+ }
+ totalError /= 1024.0f;
+ if (LOG_TIMING) {
+ long finalMillis = System.currentTimeMillis();
+ Log.d(LOG_TAG, "dvk: first part took " + (middleMillis - startMillis) + "ms");
+ Log.d(LOG_TAG, "dvk: last part took " + (finalMillis - middleMillis) + "ms");
+ }
+ if (LOG_CALC) {
+ Log.d(LOG_TAG, "dvk: error " + totalError + ", pixels " + interestingPixels);
+ }
+ return totalError / interestingPixels;
+ }
+
+ private static boolean inspectRegion(Bitmap ideal, int x, int y) {
+ int regionColor = ideal.getPixel(x, y);
+ for (int i = 0; i < REGION_SIZE; i++) {
+ for (int j = 0; j < REGION_SIZE; j++) {
+ if (ideal.getPixel(x + i, y + j) != regionColor)
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/MainView.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/MainView.java
new file mode 100644
index 0000000000000..454fe7b50ad79
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/MainView.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.util.AttributeSet;
+import android.view.View;
+
+public class MainView extends View {
+ Paint mPaint = new Paint();
+
+ public MainView(Context context) {
+ super(context);
+ }
+
+ public MainView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ public MainView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ mPaint.reset();
+ DisplayModifier.apply(mPaint, canvas);
+
+ if (mDrawCallback != null) {
+ mDrawCallback.run();
+ }
+ }
+
+ private Runnable mDrawCallback;
+ public void addDrawCallback(Runnable drawCallback) {
+ mDrawCallback = drawCallback;
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/ManualActivity.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/ManualActivity.java
new file mode 100644
index 0000000000000..400dff026293b
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/ManualActivity.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import com.android.test.hwuicompare.R;
+
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.Spinner;
+import android.widget.TextView;
+
+public class ManualActivity extends CompareActivity {
+ private static final String LOG_TAG = "ManualActivity";
+ private ImageView mCompareImageView;
+ private Bitmap mCompareBitmap;
+ private TextView mErrorTextView;
+ private MainView mSoftwareView;
+
+ private static final int COMPARE_VIEW_UNINITIALIZED = -1;
+ private static final int COMPARE_VIEW_HARDWARE = 0;
+ private static final int COMPARE_VIEW_SOFTWARE = 1;
+ private static final int COMPARE_VIEW_HEATMAP = 2; // TODO: add more like this? any ideas?
+
+ private int mCompareImageViewState = COMPARE_VIEW_UNINITIALIZED;
+ private int mLastCompareImageViewState = COMPARE_VIEW_UNINITIALIZED;
+
+ Runnable mRunnable = new Runnable() {
+ @Override
+ public void run() {
+ Log.d(LOG_TAG, "mRunnable running, mRedrewFlag = " + mRedrewFlag);
+
+ if (mRedrewFlag) {
+ loadBitmaps();
+ // recalculate error
+ float error = mErrorCalculator.calcErrorRS(mSoftwareBitmap, mHardwareBitmap);
+ String modname = "";
+ for (String s : DisplayModifier.getLastAppliedModifications()) {
+ modname = modname.concat(s + ".");
+ }
+
+ Log.d(LOG_TAG, "error for " + modname + " is " + error);
+ mErrorTextView.setText(String.format("%.4f", error));
+ }
+
+ if (mCompareImageViewState != mLastCompareImageViewState || mRedrewFlag) {
+ switch (mCompareImageViewState) {
+ case COMPARE_VIEW_UNINITIALIZED:
+ // set to hardware
+ case COMPARE_VIEW_HARDWARE:
+ mCompareImageView.setImageBitmap(mHardwareBitmap);
+ break;
+ case COMPARE_VIEW_SOFTWARE:
+ mCompareImageView.setImageBitmap(mSoftwareBitmap);
+ break;
+ case COMPARE_VIEW_HEATMAP:
+ mErrorCalculator.calcErrorHeatmapRS(mSoftwareBitmap, mHardwareBitmap,
+ mCompareBitmap);
+ mCompareImageView.setImageBitmap(mCompareBitmap);
+ break;
+ }
+ mCompareImageView.invalidate();
+ }
+
+ mLastCompareImageViewState = mCompareImageViewState;
+ mRedrewFlag = false;
+ mHandler.removeCallbacks(mRunnable);
+ }
+ };
+
+ private void redrawViews() {
+ mHardwareView.invalidate();
+ mSoftwareView.invalidate();
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.manual_layout);
+ onCreateCommon(mRunnable);
+
+ mSoftwareView = (MainView) findViewById(R.id.software_view);
+ mSoftwareView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+ mSoftwareView.setBackgroundColor(Color.WHITE);
+ mSoftwareView.addDrawCallback(mDrawCallback);
+
+ mCompareImageView = (ImageView) findViewById(R.id.compare_image_view);
+
+ int width = getResources().getDimensionPixelSize(R.dimen.layer_width);
+ int height = getResources().getDimensionPixelSize(R.dimen.layer_height);
+ mCompareBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+
+ mErrorTextView = (TextView) findViewById(R.id.current_error);
+ ((ImageButton) findViewById(R.id.next)).setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ DisplayModifier.step();
+ updateSpinners();
+ redrawViews();
+ }
+ });
+ ((ImageButton) findViewById(R.id.previous)).setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ DisplayModifier.stepBack();
+ updateSpinners();
+ redrawViews();
+ }
+ });
+ ((Button) findViewById(R.id.show_hardware_version))
+ .setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mCompareImageViewState = COMPARE_VIEW_HARDWARE;
+ mHandler.post(mRunnable);
+ }
+ });
+ ((Button) findViewById(R.id.show_software_version))
+ .setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mCompareImageViewState = COMPARE_VIEW_SOFTWARE;
+ mHandler.post(mRunnable);
+ }
+ });
+ ((Button) findViewById(R.id.show_error_heatmap)).setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mCompareImageViewState = COMPARE_VIEW_HEATMAP;
+ mHandler.post(mRunnable);
+ }
+ });
+
+ buildSpinnerLayout();
+ }
+
+ private class DisplayModifierSpinner extends Spinner {
+ private final int mIndex;
+
+ public DisplayModifierSpinner(int index) {
+ super(ManualActivity.this);
+ mIndex = index;
+ setOnItemSelectedListener(new OnItemSelectedListener() {
+
+ @Override
+ public void onItemSelected(AdapterView parentView, View selectedItem,
+ int position, long id) {
+ DisplayModifier.setIndex(mIndex, position);
+ redrawViews();
+ }
+
+ @Override
+ public void onNothingSelected(AdapterView parentView) {
+ }
+ });
+ }
+ }
+
+ private Spinner[] mSpinners;
+
+ private void buildSpinnerLayout() {
+ LinearLayout layout = (LinearLayout) findViewById(R.id.spinner_layout);
+ String[][] mapsStrings = DisplayModifier.getStrings();
+ mSpinners = new Spinner[mapsStrings.length];
+ int index = 0;
+ for (String[] spinnerValues : mapsStrings) {
+ mSpinners[index] = new DisplayModifierSpinner(index);
+ mSpinners[index].setAdapter(new ArrayAdapter(this,
+ android.R.layout.simple_spinner_dropdown_item, spinnerValues));
+ layout.addView(mSpinners[index]);
+ index++;
+ }
+ Log.d(LOG_TAG, "created " + index + " spinners");
+ }
+
+ private void updateSpinners() {
+ int[] indices = DisplayModifier.getIndices();
+ for (int i = 0; i < mSpinners.length; i++) {
+ mSpinners[i].setSelection(indices[i]);
+ }
+ }
+
+ @Override
+ protected boolean forceRecreateBitmaps() {
+ // continually recreate bitmaps to avoid modifying bitmaps currently being drawn
+ return true;
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/ResourceModifiers.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/ResourceModifiers.java
new file mode 100644
index 0000000000000..c7054434c2269
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/ResourceModifiers.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.hwuicompare;
+
+import com.android.test.hwuicompare.R;
+
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.BitmapShader;
+import android.graphics.Color;
+import android.graphics.LinearGradient;
+import android.graphics.Matrix;
+import android.graphics.Shader;
+
+public class ResourceModifiers {
+ public final BitmapShader mRepeatShader;
+ public final BitmapShader mTranslatedShader;
+ public final BitmapShader mScaledShader;
+ private final int mTexWidth;
+ private final int mTexHeight;
+ private final float mDrawWidth;
+ private final float mDrawHeight;
+ public final LinearGradient mHorGradient;
+ public final LinearGradient mDiagGradient;
+ public final LinearGradient mVertGradient;
+ public final Bitmap mBitmap;
+ private final Matrix mMtx1;
+ private final Matrix mMtx2;
+ private final Matrix mMtx3;
+
+ public final float[] mBitmapVertices;
+ public final int[] mBitmapColors;
+
+ private static ResourceModifiers sInstance = null;
+ public static ResourceModifiers instance() { return sInstance; }
+ public static void init(Resources resources) {
+ sInstance = new ResourceModifiers(resources);
+ }
+
+ public ResourceModifiers(Resources resources) {
+ mBitmap = BitmapFactory.decodeResource(resources, R.drawable.sunset1);
+ mTexWidth = mBitmap.getWidth();
+ mTexHeight = mBitmap.getHeight();
+
+ mDrawWidth = resources.getDimensionPixelSize(R.dimen.layer_width);
+ mDrawHeight = resources.getDimensionPixelSize(R.dimen.layer_height);
+
+ mRepeatShader = new BitmapShader(mBitmap, Shader.TileMode.REPEAT,
+ Shader.TileMode.REPEAT);
+
+ mTranslatedShader = new BitmapShader(mBitmap, Shader.TileMode.REPEAT,
+ Shader.TileMode.REPEAT);
+ mMtx1 = new Matrix();
+ mMtx1.setTranslate(mTexWidth / 2.0f, mTexHeight / 2.0f);
+ mMtx1.postRotate(45, 0, 0);
+ mTranslatedShader.setLocalMatrix(mMtx1);
+
+ mScaledShader = new BitmapShader(mBitmap, Shader.TileMode.MIRROR,
+ Shader.TileMode.MIRROR);
+ mMtx2 = new Matrix();
+ mMtx2.setScale(0.5f, 0.5f);
+ mScaledShader.setLocalMatrix(mMtx2);
+
+ mHorGradient = new LinearGradient(0.0f, 0.0f, 1.0f, 0.0f,
+ Color.RED, Color.GREEN, Shader.TileMode.CLAMP);
+ mMtx3 = new Matrix();
+ mMtx3.setScale(mDrawHeight, 1.0f);
+ mMtx3.postRotate(-90.0f);
+ mMtx3.postTranslate(0.0f, mDrawHeight);
+ mHorGradient.setLocalMatrix(mMtx3);
+
+ mDiagGradient = new LinearGradient(0.0f, 0.0f, mDrawWidth / 2.0f, mDrawHeight / 2.0f,
+ Color.BLUE, Color.RED, Shader.TileMode.CLAMP);
+
+ mVertGradient = new LinearGradient(0.0f, 0.0f, 0.0f, mDrawHeight / 2.0f,
+ Color.YELLOW, Color.MAGENTA, Shader.TileMode.MIRROR);
+
+ final float width = mBitmap.getWidth() / 8.0f;
+ final float height = mBitmap.getHeight() / 8.0f;
+
+ mBitmapVertices = new float[] {
+ 0.0f, 0.0f, width, 0.0f, width * 2, 0.0f, width * 3, 0.0f,
+ 0.0f, height, width, height, width * 2, height, width * 4, height,
+ 0.0f, height * 2, width, height * 2, width * 2, height * 2, width * 3, height * 2,
+ 0.0f, height * 4, width, height * 4, width * 2, height * 4, width * 4, height * 4,
+ };
+
+ mBitmapColors = new int[] {
+ 0xffff0000, 0xff00ff00, 0xff0000ff, 0xffff0000,
+ 0xff0000ff, 0xffff0000, 0xff00ff00, 0xff00ff00,
+ 0xff00ff00, 0xff0000ff, 0xffff0000, 0xff00ff00,
+ 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ff0000,
+ };
+ }
+
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/Test.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/Test.java
new file mode 100644
index 0000000000000..6ea8237474db4
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/Test.java
@@ -0,0 +1,46 @@
+package com.android.test.hwuicompare;
+
+import com.android.test.hwuicompare.AutomaticActivity.TestCallback;
+
+import android.os.Bundle;
+import android.test.ActivityInstrumentationTestCase2;
+
+public class Test extends ActivityInstrumentationTestCase2 {
+ AutomaticActivity mActivity;
+ private Bundle mBundle;
+
+ public Test() {
+ super(AutomaticActivity.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mBundle = new Bundle();
+ mActivity = getActivity();
+ mActivity.setCallback(new TestCallback() {
+
+ @Override
+ void report(String key, float value) {
+ mBundle.putFloat(key, value);
+ }
+ @Override
+ void complete() {
+ synchronized(mBundle) {
+ mBundle.notify();
+ }
+ }
+ });
+ }
+
+ public void testCanvas() {
+ synchronized(mBundle) {
+ try {
+ mBundle.wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ getInstrumentation().sendStatus(0, mBundle);
+ }
+}
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/errorCalculator.rs b/tests/CanvasCompare/src/com/android/test/hwuicompare/errorCalculator.rs
new file mode 100644
index 0000000000000..668f61d6254d0
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/errorCalculator.rs
@@ -0,0 +1,56 @@
+#pragma version(1)
+#pragma rs java_package_name(com.android.test.hwuicompare)
+
+int REGION_SIZE;
+int WIDTH;
+int HEIGHT;
+
+const uchar4 *ideal;
+const uchar4 *given;
+
+void countInterestingRegions(const int32_t *v_in, int32_t *v_out) {
+ int y = v_in[0];
+ v_out[0] = 0;
+
+ for (int x = 0; x < HEIGHT; x += REGION_SIZE) {
+ bool interestingRegion = false;
+ int regionColor = (int)ideal[y * WIDTH + x];
+ for (int i = 0; i < REGION_SIZE && !interestingRegion; i++) {
+ for (int j = 0; j < REGION_SIZE && !interestingRegion; j++) {
+ interestingRegion |= (int)(ideal[(y + i) * WIDTH + (x + j)]) != regionColor;
+ }
+ }
+ if (interestingRegion) {
+ v_out[0]++;
+ }
+ }
+}
+
+void accumulateError(const int32_t *v_in, int32_t *v_out) {
+ int startY = v_in[0];
+ int error = 0;
+ for (int y = startY; y < startY + REGION_SIZE; y++) {
+ for (int x = 0; x < HEIGHT; x++) {
+ uchar4 idealPixel = ideal[y * WIDTH + x];
+ uchar4 givenPixel = given[y * WIDTH + x];
+ error += abs(idealPixel.x - givenPixel.x);
+ error += abs(idealPixel.y - givenPixel.y);
+ error += abs(idealPixel.z - givenPixel.z);
+ error += abs(idealPixel.w - givenPixel.w);
+ }
+ }
+ v_out[0] = error;
+}
+
+void displayDifference(const uchar4 *v_in, uchar4 *v_out, uint32_t x, uint32_t y) {
+ float4 idealPixel = rsUnpackColor8888(ideal[y * WIDTH + x]);
+ float4 givenPixel = rsUnpackColor8888(given[y * WIDTH + x]);
+
+ float4 diff = idealPixel - givenPixel;
+ float totalDiff = diff.x + diff.y + diff.z + diff.w;
+ if (totalDiff < 0) {
+ v_out[0] = rsPackColorTo8888(0, 0, clamp(-totalDiff/2, 0, 1));
+ } else {
+ v_out[0] = rsPackColorTo8888(clamp(totalDiff/2, 0, 1), 0, 0);
+ }
+}