am d542f1eb: am af79a593: Fix histogram intrinsic.
* commit 'd542f1ebdf6917c4e4bbdf6cb657583a8fe4bd01':
Fix histogram intrinsic.
diff --git a/cpp/Android.mk b/cpp/Android.mk
index d266d14..b32d7f1 100644
--- a/cpp/Android.mk
+++ b/cpp/Android.mk
@@ -21,9 +21,11 @@
RS_VERSION := "(1 + $(PLATFORM_SDK_VERSION))"
endif
local_cflags_for_rs_cpp += -DRS_VERSION=$(RS_VERSION)
+local_cflags_for_rs_cpp += -Wno-unused-parameter
LOCAL_SRC_FILES := $(rs_cpp_SRC_FILES)
+LOCAL_CLANG := true
LOCAL_CFLAGS += $(local_cflags_for_rs_cpp)
LOCAL_SHARED_LIBRARIES := \
@@ -47,6 +49,7 @@
include $(CLEAR_VARS)
+LOCAL_CLANG := true
LOCAL_CFLAGS += $(local_cflags_for_rs_cpp)
LOCAL_SRC_FILES := $(rs_cpp_SRC_FILES)
diff --git a/java/tests/Balls/src/com/example/android/rs/balls/ball_physics.rs b/java/tests/Balls/src/com/example/android/rs/balls/ball_physics.rs
index 5b5d2e0..a8c781d 100644
--- a/java/tests/Balls/src/com/example/android/rs/balls/ball_physics.rs
+++ b/java/tests/Balls/src/com/example/android/rs/balls/ball_physics.rs
@@ -60,11 +60,11 @@
float2 vec2 = vec * vec;
float len2 = vec2.x + vec2.y;
- if ((len2 < 10000.f) && (len2 > 0.f)) {
- float t = native_powr(len2, 1.5f) + 16.0f;
- float2 pfv = (vec / t) * 16000.f;
- pressure += length(pfv);
- fv -= pfv;
+ if ((len2 < 10000.f) && (len2 > 0.001f)) {
+ float len = rsqrt(len2 + 4.f);
+ float f = (len * len * len) * 20000.f;
+ fv -= vec * f;
+ pressure += f;
}
}
}
@@ -137,7 +137,7 @@
}
// low pressure ~500, high ~2500
- pressure = max(pressure - 400.f, 0.f);
+ pressure *= 12.f;
ball->pressure = pressure;
//rsDebug("p ", pressure);
diff --git a/java/tests/Balls/src/com/example/android/rs/balls/balls.rs b/java/tests/Balls/src/com/example/android/rs/balls/balls.rs
index 9be9f38..077916d 100644
--- a/java/tests/Balls/src/com/example/android/rs/balls/balls.rs
+++ b/java/tests/Balls/src/com/example/android/rs/balls/balls.rs
@@ -46,8 +46,9 @@
int2 gridDims = (int2){ rsAllocationGetDimX(gGrid),
rsAllocationGetDimY(gGrid) };
- rs_allocation ain = rsGetAllocation(balls);
- int32_t dimX = rsAllocationGetDimX(ain);
+ rs_allocation aNull; // Empty rs_allocation, since we don't have an input.
+ rs_allocation aout = rsGetAllocation(balls);
+ int32_t dimX = rsAllocationGetDimX(aout);
// Binning
// Clear the particle list
@@ -92,7 +93,7 @@
}
- rsForEach(physics_script, ain, ain);
+ rsForEach(physics_script, aNull, aout);
for (uint32_t ct=0; ct < dimX; ct++) {
point[ct].position = balls[ct].position;
diff --git a/java/tests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/java/tests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
index 2dc7f07..645b827 100644
--- a/java/tests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
+++ b/java/tests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
@@ -112,7 +112,6 @@
* Define enum type for test names
*/
public enum TestName {
- // totally there are 38 test cases
LEVELS_VEC3_RELAXED ("Levels Vec3 Relaxed"),
LEVELS_VEC4_RELAXED ("Levels Vec4 Relaxed"),
LEVELS_VEC3_FULL ("Levels Vec3 Full"),
@@ -168,8 +167,6 @@
}
}
- Bitmap mBitmapIn;
- Bitmap mBitmapIn2;
Bitmap mBitmapOut;
private Spinner mSpinner;
@@ -184,12 +181,9 @@
private TextView mText4;
private TextView mText5;
- private float mSaturation = 1.0f;
-
private TextView mBenchmarkResult;
private Spinner mTestSpinner;
- private SurfaceView mSurfaceView;
private ImageView mDisplayView;
private boolean mDoingBenchmark;
@@ -422,7 +416,7 @@
break;
}
- mTest.createBaseTest(this, mBitmapIn, mBitmapIn2, mBitmapOut);
+ mTest.createBaseTest(this);
setupBars();
mTest.runTest();
@@ -447,12 +441,15 @@
};
void init() {
- mBitmapIn = loadBitmap(R.drawable.img1600x1067);
- mBitmapIn2 = loadBitmap(R.drawable.img1600x1067b);
- mBitmapOut = Bitmap.createBitmap(mBitmapIn.getWidth(), mBitmapIn.getHeight(),
- mBitmapIn.getConfig());
-
- mSurfaceView = (SurfaceView) findViewById(R.id.surface);
+ mRS = RenderScript.create(this);
+ mInPixelsAllocation = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1600x1067);
+ mInPixelsAllocation2 = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1600x1067b);
+ mBitmapOut = Bitmap.createBitmap(mInPixelsAllocation.getType().getX(),
+ mInPixelsAllocation.getType().getY(),
+ Bitmap.Config.ARGB_8888);
+ mOutPixelsAllocation = Allocation.createFromBitmap(mRS, mBitmapOut);
mDisplayView = (ImageView) findViewById(R.id.display);
mDisplayView.setImageBitmap(mBitmapOut);
@@ -483,21 +480,6 @@
mBenchmarkResult = (TextView) findViewById(R.id.benchmarkText);
mBenchmarkResult.setText("Result: not run");
-
- mRS = RenderScript.create(this);
- mInPixelsAllocation = Allocation.createFromBitmap(mRS, mBitmapIn,
- Allocation.MipmapControl.MIPMAP_NONE,
- Allocation.USAGE_SHARED |
- Allocation.USAGE_GRAPHICS_TEXTURE |
- Allocation.USAGE_SCRIPT);
- mInPixelsAllocation2 = Allocation.createFromBitmap(mRS, mBitmapIn2,
- Allocation.MipmapControl.MIPMAP_NONE,
- Allocation.USAGE_SHARED |
- Allocation.USAGE_GRAPHICS_TEXTURE |
- Allocation.USAGE_SCRIPT);
- mOutPixelsAllocation = Allocation.createFromBitmap(mRS, mBitmapOut);
-
-
setupTests();
changeTest(TestName.LEVELS_VEC3_RELAXED);
}
@@ -519,8 +501,6 @@
mInPixelsAllocation = null;
mInPixelsAllocation2 = null;
mOutPixelsAllocation = null;
- mBitmapIn = null;
- mBitmapIn2 = null;
mBitmapOut = null;
}
@@ -547,12 +527,6 @@
init();
}
- private Bitmap loadBitmap(int resource) {
- final BitmapFactory.Options options = new BitmapFactory.Options();
- options.inPreferredConfig = Bitmap.Config.ARGB_8888;
- return BitmapFactory.decodeResource(getResources(), resource, options);
- }
-
// button hook
public void benchmark(View v) {
float t = getBenchmark();
@@ -622,6 +596,7 @@
mTest.exitBenchmark();
mDoingBenchmark = false;
+
return ft;
}
}
diff --git a/java/tests/ImageProcessing/src/com/android/rs/image/TestBase.java b/java/tests/ImageProcessing/src/com/android/rs/image/TestBase.java
index a353d9c..cfa9897 100644
--- a/java/tests/ImageProcessing/src/com/android/rs/image/TestBase.java
+++ b/java/tests/ImageProcessing/src/com/android/rs/image/TestBase.java
@@ -19,9 +19,7 @@
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
-import android.graphics.BitmapFactory;
import android.graphics.Bitmap;
-import android.graphics.Canvas;
import android.renderscript.ScriptC;
import android.renderscript.RenderScript;
import android.renderscript.Type;
@@ -104,7 +102,7 @@
return false;
}
- public final void createBaseTest(ImageProcessingActivity ipact, Bitmap b, Bitmap b2, Bitmap outb) {
+ public final void createBaseTest(ImageProcessingActivity ipact) {
act = ipact;
mRS = ipact.mRS;
mRS.setMessageHandler(new MessageProcessor(act));
diff --git a/java/tests/ImageProcessing_jb/Android.mk b/java/tests/ImageProcessing_jb/Android.mk
index 20d6be7..680c1de 100644
--- a/java/tests/ImageProcessing_jb/Android.mk
+++ b/java/tests/ImageProcessing_jb/Android.mk
@@ -24,6 +24,6 @@
#LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript
LOCAL_PACKAGE_NAME := ImageProcessingJB
-LOCAL_SDK_VERSION := 17
+LOCAL_SDK_VERSION := 18
include $(BUILD_PACKAGE)
diff --git a/java/tests/ImageProcessing_jb/AndroidManifest.xml b/java/tests/ImageProcessing_jb/AndroidManifest.xml
index b3fcfc4..7d42883 100644
--- a/java/tests/ImageProcessing_jb/AndroidManifest.xml
+++ b/java/tests/ImageProcessing_jb/AndroidManifest.xml
@@ -4,11 +4,17 @@
package="com.android.rs.imagejb">
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-sdk android:minSdkVersion="11" />
- <application android:label="Image Processing JB"
+ <application android:label="IP-18"
android:hardwareAccelerated="true">
<activity android:name="ImageProcessingActivityJB">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
+ </intent-filter>
+ </activity>
+
+ <activity class=".IPControlsJB" android:name="IPControlsJB">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720a.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720a.jpg
new file mode 100644
index 0000000..ff09574
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720a.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720b.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720b.jpg
new file mode 100644
index 0000000..e9f6aa4
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1280x720b.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067.jpg
deleted file mode 100644
index 05d3ee2..0000000
--- a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067.jpg
+++ /dev/null
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067b.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067b.jpg
deleted file mode 100644
index aed0781..0000000
--- a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1600x1067b.jpg
+++ /dev/null
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080a.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080a.jpg
new file mode 100644
index 0000000..80b16ab
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080a.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080b.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080b.jpg
new file mode 100644
index 0000000..b4883d6
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img1920x1080b.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160a.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160a.jpg
new file mode 100644
index 0000000..871b22c
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160a.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160b.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160b.jpg
new file mode 100644
index 0000000..281bed0
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img3840x2160b.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450a.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450a.jpg
new file mode 100644
index 0000000..6d5b623
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450a.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450b.jpg b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450b.jpg
new file mode 100644
index 0000000..2013e07
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/drawable-nodpi/img800x450b.jpg
Binary files differ
diff --git a/java/tests/ImageProcessing_jb/res/layout/controls.xml b/java/tests/ImageProcessing_jb/res/layout/controls.xml
new file mode 100644
index 0000000..0e89dd9
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/res/layout/controls.xml
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 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.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:orientation="vertical"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent"
+ android:id="@+id/toplevel">
+
+ <Spinner
+ android:id="@+id/image_size"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"/>
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="fill_parent" android:layout_height="wrap_content">
+ <ToggleButton android:id="@+id/io_control"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:textColorLink="@android:color/holo_blue_light"
+ android:textOff="@string/io_control_on"
+ android:textOn="@string/io_control_off"
+ android:textSize="12dp"/>
+ <ToggleButton
+ android:id="@+id/length_control"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:textColorLink="@android:color/holo_blue_light"
+ android:textOff="@string/length_long"
+ android:textOn="@string/length_short"
+ android:textSize="12dp"/>
+ <ToggleButton
+ android:id="@+id/background_work"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:textColorLink="@android:color/holo_blue_light"
+ android:textOff="@string/dvfs_on"
+ android:textOn="@string/dvfs_off"
+ android:textSize="12dp"/>
+ <ToggleButton
+ android:id="@+id/pause"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:textColorLink="@android:color/holo_blue_light"
+ android:textOff="@string/pause_on"
+ android:textOn="@string/pause_off"
+ android:textSize="12dp"/>
+ </LinearLayout>
+
+ <ListView
+ android:id="@+id/test_list"
+ android:layout_weight="0.2"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"/>
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="fill_parent" android:layout_height="wrap_content">
+ <Button
+ android:id="@+id/select_all"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/select_all"
+ android:textSize="12dp"
+ android:onClick="btnSelAll"/>
+ <Button
+ android:id="@+id/select_none"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/select_none"
+ android:textSize="12dp"
+ android:onClick="btnSelNone"/>
+ <Button
+ android:id="@+id/select_hp"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/select_hp"
+ android:textSize="12dp"
+ android:onClick="btnSelHp"/>
+ <Button
+ android:id="@+id/select_lp"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/select_lp"
+ android:textSize="12dp"
+ android:onClick="btnSelLp"/>
+ <Button
+ android:id="@+id/select_intrinsics"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/select_intrinsics"
+ android:textSize="12dp"
+ android:onClick="btnSelIntrinsic"/>
+ </LinearLayout>
+
+ <Button
+ android:id="@+id/run"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/benchmark"
+ android:onClick="btnRun"/>
+
+ <TextView
+ android:id="@+id/results"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:textSize="8pt"
+ android:layout_marginLeft="10sp"
+ android:layout_marginTop="15sp"
+ android:text="@string/results"/>
+
+</LinearLayout>
+
diff --git a/java/tests/ImageProcessing_jb/res/layout/main.xml b/java/tests/ImageProcessing_jb/res/layout/main.xml
index f0a2b92..f98d05d 100644
--- a/java/tests/ImageProcessing_jb/res/layout/main.xml
+++ b/java/tests/ImageProcessing_jb/res/layout/main.xml
@@ -30,33 +30,24 @@
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
- <ImageView
- android:id="@+id/display"
- android:layout_width="wrap_content"
- android:layout_height="wrap_content" />
+
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
- android:layout_width="fill_parent"
+ android:layout_width="wrap_content"
android:layout_height="wrap_content">
- <Button
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="@string/benchmark"
- android:onClick="benchmark"/>
- <TextView
- android:id="@+id/benchmarkText"
- android:layout_width="match_parent"
- android:layout_height="wrap_content"
- android:textSize="8pt"
- android:text="@string/saturation"/>
+ <view class="com.android.rs.imagejb.ImageProcessingActivityJB$SizedTV"
+ android:id="@+id/display"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content" />
+ <ImageView
+ android:id="@+id/display2"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content" />
</LinearLayout>
- <Spinner
- android:id="@+id/filterselection"
- android:layout_width="fill_parent"
- android:layout_height="wrap_content"/>
+
<Spinner
android:id="@+id/spinner1"
- android:layout_width="fill_parent"
+ android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:id="@+id/slider1Text"
@@ -128,11 +119,6 @@
android:layout_marginRight="10sp"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
- <Button
- android:layout_width="wrap_content"
- android:layout_height="wrap_content"
- android:text="@string/benchmark_all"
- android:onClick="benchmark_all"/>
</LinearLayout>
</ScrollView>
</LinearLayout>
diff --git a/java/tests/ImageProcessing_jb/res/values/strings.xml b/java/tests/ImageProcessing_jb/res/values/strings.xml
index a7dd165..fdaefcd 100644
--- a/java/tests/ImageProcessing_jb/res/values/strings.xml
+++ b/java/tests/ImageProcessing_jb/res/values/strings.xml
@@ -29,6 +29,23 @@
<string name="gamma">Gamma</string>
<string name="saturation">Saturation</string>
<string name="benchmark">Benchmark</string>
- <string name="benchmark_all">Benchmark All</string>
+
+ <string name="results">Results: not run</string>
+
+ <string name="io_control_on">USAGE_IO</string>
+ <string name="io_control_off">USAGE_IO</string>
+ <string name="length_long">Long run</string>
+ <string name="length_short">Long run</string>
+ <string name="dvfs_on">Background work</string>
+ <string name="dvfs_off">Background work</string>
+ <string name="run_all">Benchmark All</string>
+ <string name="run_one">Benchmark One</string>
+ <string name="select_all">All</string>
+ <string name="select_none">None</string>
+ <string name="select_hp">Full FP</string>
+ <string name="select_lp">Relaxed FP</string>
+ <string name="pause_on">Pause</string>
+ <string name="pause_off">Pause</string>
+ <string name="select_intrinsics">Intrinsics</string>
</resources>
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blend.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blend.java
index 302dc31..098830b 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blend.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blend.java
@@ -25,7 +25,6 @@
import android.renderscript.RenderScript;
import android.renderscript.Script;
import android.renderscript.ScriptC;
-import android.renderscript.ScriptGroup;
import android.renderscript.ScriptIntrinsicBlend;
import android.renderscript.Type;
import android.util.Log;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blur25G.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blur25G.java
new file mode 100644
index 0000000..6e0cf59
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Blur25G.java
@@ -0,0 +1,99 @@
+/*
+ * 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.rs.imagejb;
+
+import java.lang.Math;
+
+import android.graphics.Bitmap;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.ScriptIntrinsicBlur;
+import android.renderscript.ScriptIntrinsicColorMatrix;
+import android.renderscript.Type;
+import android.renderscript.Matrix4f;
+import android.util.Log;
+import android.widget.SeekBar;
+import android.widget.TextView;
+
+public class Blur25G extends TestBase {
+ private final int MAX_RADIUS = 25;
+ private float mRadius = MAX_RADIUS;
+
+ private ScriptIntrinsicBlur mIntrinsic;
+
+ private ScriptC_greyscale mScript;
+ private Allocation mScratchPixelsAllocation1;
+ private Allocation mScratchPixelsAllocation2;
+
+
+ public Blur25G() {
+ }
+
+ public boolean onBar1Setup(SeekBar b, TextView t) {
+ t.setText("Radius");
+ b.setProgress(100);
+ return true;
+ }
+
+
+ public void onBar1Changed(int progress) {
+ mRadius = ((float)progress) / 100.0f * MAX_RADIUS;
+ if (mRadius <= 0.10f) {
+ mRadius = 0.10f;
+ }
+ mIntrinsic.setRadius(mRadius);
+ }
+
+
+ public void createTest(android.content.res.Resources res) {
+ int width = mInPixelsAllocation.getType().getX();
+ int height = mInPixelsAllocation.getType().getY();
+
+ Type.Builder tb = new Type.Builder(mRS, Element.U8(mRS));
+ tb.setX(width);
+ tb.setY(height);
+ mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create());
+ mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create());
+
+ mScript = new ScriptC_greyscale(mRS);
+ mScript.forEach_toU8(mInPixelsAllocation, mScratchPixelsAllocation1);
+
+ mIntrinsic = ScriptIntrinsicBlur.create(mRS, Element.U8(mRS));
+ mIntrinsic.setRadius(MAX_RADIUS);
+ mIntrinsic.setInput(mScratchPixelsAllocation1);
+ }
+
+ public void runTest() {
+ mIntrinsic.forEach(mScratchPixelsAllocation2);
+ }
+
+ public void setupBenchmark() {
+ mIntrinsic.setRadius(MAX_RADIUS);
+ }
+
+ public void exitBenchmark() {
+ mIntrinsic.setRadius(mRadius);
+ }
+
+ public void updateBitmap(Bitmap b) {
+ mScript.forEach_toU8_4(mScratchPixelsAllocation2, mOutPixelsAllocation);
+ mOutPixelsAllocation.copyTo(b);
+ }
+
+}
+
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorCube.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorCube.java
new file mode 100644
index 0000000..0153f40
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorCube.java
@@ -0,0 +1,87 @@
+/*
+ * 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.rs.imagejb;
+
+import java.lang.Math;
+
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.Matrix4f;
+import android.renderscript.RenderScript;
+import android.renderscript.Script;
+import android.renderscript.ScriptC;
+import android.renderscript.ScriptIntrinsic3DLUT;
+import android.renderscript.ScriptIntrinsicColorMatrix;
+import android.renderscript.Type;
+import android.util.Log;
+
+public class ColorCube extends TestBase {
+ private Allocation mCube;
+ private ScriptC_colorcube mScript;
+ private ScriptIntrinsic3DLUT mIntrinsic;
+ private boolean mUseIntrinsic;
+
+ public ColorCube(boolean useIntrinsic) {
+ mUseIntrinsic = useIntrinsic;
+ }
+
+ private void initCube() {
+ final int sx = 32;
+ final int sy = 32;
+ final int sz = 16;
+
+ Type.Builder tb = new Type.Builder(mRS, Element.U8_4(mRS));
+ tb.setX(sx);
+ tb.setY(sy);
+ tb.setZ(sz);
+ Type t = tb.create();
+ mCube = Allocation.createTyped(mRS, t);
+
+ int dat[] = new int[sx * sy * sz];
+ for (int z = 0; z < sz; z++) {
+ for (int y = 0; y < sy; y++) {
+ for (int x = 0; x < sx; x++ ) {
+ int v = 0xff000000;
+ v |= (0xff * x / (sx - 1));
+ v |= (0xff * y / (sy - 1)) << 8;
+ v |= (0xff * z / (sz - 1)) << 16;
+ dat[z*sy*sx + y*sx + x] = v;
+ }
+ }
+ }
+
+ mCube.copyFromUnchecked(dat);
+ }
+
+ public void createTest(android.content.res.Resources res) {
+ mScript = new ScriptC_colorcube(mRS, res, R.raw.colorcube);
+ mIntrinsic = ScriptIntrinsic3DLUT.create(mRS, Element.U8_4(mRS));
+
+ initCube();
+ mScript.invoke_setCube(mCube);
+ mIntrinsic.setLUT(mCube);
+ }
+
+ public void runTest() {
+ if (mUseIntrinsic) {
+ mIntrinsic.forEach(mInPixelsAllocation, mOutPixelsAllocation);
+ } else {
+ mScript.forEach_root(mInPixelsAllocation, mOutPixelsAllocation);
+ }
+ }
+
+}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorMatrix.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorMatrix.java
index 5053d4d..a3823b6 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorMatrix.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ColorMatrix.java
@@ -24,7 +24,6 @@
import android.renderscript.RenderScript;
import android.renderscript.Script;
import android.renderscript.ScriptC;
-import android.renderscript.ScriptGroup;
import android.renderscript.ScriptIntrinsicColorMatrix;
import android.renderscript.Type;
import android.util.Log;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve3x3.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve3x3.java
index d7acf4a..f70f7b4 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve3x3.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve3x3.java
@@ -24,7 +24,6 @@
import android.renderscript.RenderScript;
import android.renderscript.Script;
import android.renderscript.ScriptC;
-import android.renderscript.ScriptGroup;
import android.renderscript.ScriptIntrinsicConvolve3x3;
import android.renderscript.Type;
import android.util.Log;
@@ -64,7 +63,11 @@
}
public void runTest() {
- mScript.forEach_root(mOutPixelsAllocation);
+ if (mUseIntrinsic) {
+ mIntrinsic.forEach(mOutPixelsAllocation);
+ } else {
+ mScript.forEach_root(mOutPixelsAllocation);
+ }
}
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve5x5.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve5x5.java
index d1dbb1f..c332074 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve5x5.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/Convolve5x5.java
@@ -24,7 +24,6 @@
import android.renderscript.RenderScript;
import android.renderscript.Script;
import android.renderscript.ScriptC;
-import android.renderscript.ScriptGroup;
import android.renderscript.ScriptIntrinsicConvolve5x5;
import android.renderscript.Type;
import android.util.Log;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPControlsJB.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPControlsJB.java
new file mode 100644
index 0000000..597e645
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPControlsJB.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2013 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.rs.imagejb;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.graphics.Canvas;
+import android.graphics.Point;
+import android.view.SurfaceView;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.SeekBar;
+import android.widget.Spinner;
+import android.widget.ToggleButton;
+import android.widget.TextView;
+import android.widget.CompoundButton;
+import android.widget.ListView;
+import android.view.View;
+import java.util.ArrayList;
+import java.util.ListIterator;
+import android.util.Log;
+import android.content.Intent;
+
+import android.os.Environment;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class IPControlsJB extends Activity {
+ private final String TAG = "Img";
+ public final String RESULT_FILE = "image_processing_result.csv";
+
+ private ToggleButton mIOButton;
+ private Spinner mResSpinner;
+ private ListView mTestListView;
+ private TextView mResultView;
+
+ private ArrayAdapter<String> mTestListAdapter;
+ private ArrayList<String> mTestList = new ArrayList<String>();
+
+ private boolean mToggleIO = false;
+ private boolean mToggleDVFS = true;
+ private boolean mToggleLong = false;
+ private boolean mTogglePause = false;
+
+ private float mResults[];
+
+ public enum Resolutions {
+ RES_4K(3840, 2160, "4k (3840x2160)"),
+ RES_1080P(1920, 1080, "1080p (1920x1080)"),
+ RES_720P(1280, 720, "720p (1280x720)"),
+ RES_WVGA(800, 480, "WVGA (800x480)");
+
+ private final String name;
+ public final int width;
+ public final int height;
+
+ private Resolutions(int w, int h, String s) {
+ width = w;
+ height = h;
+ name = s;
+ }
+
+ // return quoted string as displayed test name
+ public String toString() {
+ return name;
+ }
+ }
+ private Resolutions mRes;
+
+
+ private AdapterView.OnItemSelectedListener mResSpinnerListener =
+ new AdapterView.OnItemSelectedListener() {
+ public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
+ mRes = Resolutions.values()[pos];
+ }
+
+ public void onNothingSelected(AdapterView parent) {
+ }
+ };
+
+ void init() {
+ mIOButton = (ToggleButton) findViewById(R.id.io_control);
+
+ mResSpinner = (Spinner) findViewById(R.id.image_size);
+ mResSpinner.setOnItemSelectedListener(mResSpinnerListener);
+ mResSpinner.setAdapter(new ArrayAdapter<Resolutions>(
+ this, R.layout.spinner_layout, Resolutions.values()));
+
+ for (int i=0; i < IPTestListJB.TestName.values().length; i++) {
+ mTestList.add(IPTestListJB.TestName.values()[i].toString());
+ }
+
+ mTestListView = (ListView) findViewById(R.id.test_list);
+ mTestListAdapter = new ArrayAdapter(this,
+ android.R.layout.simple_list_item_activated_1,
+ mTestList);
+
+ mTestListView.setAdapter(mTestListAdapter);
+ mTestListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
+ mTestListAdapter.notifyDataSetChanged();
+
+ ToggleButton toggle;
+ toggle = (ToggleButton) findViewById(R.id.io_control);
+ toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ mToggleIO = isChecked;
+ }
+ });
+ toggle.setChecked(mToggleIO);
+
+ toggle = (ToggleButton) findViewById(R.id.length_control);
+ toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ mToggleLong = isChecked;
+ }
+ });
+ toggle.setChecked(mToggleLong);
+
+ toggle = (ToggleButton) findViewById(R.id.background_work);
+ toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ mToggleDVFS = isChecked;
+ }
+ });
+ toggle.setChecked(mToggleDVFS);
+
+ toggle = (ToggleButton) findViewById(R.id.pause);
+ toggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ mTogglePause = isChecked;
+ }
+ });
+ toggle.setChecked(mTogglePause);
+
+ mResultView = (TextView) findViewById(R.id.results);
+
+
+ Point size = new Point();
+ getWindowManager().getDefaultDisplay().getSize(size);
+ int md = (size.x > size.y) ? size.x : size.y;
+ for (int ct=0; ct < Resolutions.values().length; ct++) {
+ if (Resolutions.values()[ct].width <= (int)(md * 1.2)) {
+ mResSpinner.setSelection(ct);
+ break;
+ }
+ }
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.controls);
+ init();
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+
+ //cleanup();
+ }
+
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+
+ // init();
+ }
+
+ private void checkGroup(int group) {
+ IPTestListJB.TestName t[] = IPTestListJB.TestName.values();
+ for (int i=0; i < t.length; i++) {
+ mTestListView.setItemChecked(i, group == t[i].group);
+ }
+ }
+
+ public void btnRun(View v) {
+ IPTestListJB.TestName t[] = IPTestListJB.TestName.values();
+
+ int count = 0;
+ for (int i = 0; i < t.length; i++) {
+ if (mTestListView.isItemChecked(i)) {
+ count++;
+ }
+ }
+ if (count == 0) {
+ return;
+ }
+
+ int testList[] = new int[count];
+ count = 0;
+ for (int i = 0; i < t.length; i++) {
+ if (mTestListView.isItemChecked(i)) {
+ testList[count++] = i;
+ }
+ }
+
+ Intent intent = new Intent(this, ImageProcessingActivityJB.class);
+ intent.putExtra("tests", testList);
+ intent.putExtra("enable io", mToggleIO);
+ intent.putExtra("enable dvfs", mToggleDVFS);
+ intent.putExtra("enable long", mToggleLong);
+ intent.putExtra("enable pause", mTogglePause);
+ intent.putExtra("resolution X", mRes.width);
+ intent.putExtra("resolution Y", mRes.height);
+ startActivityForResult(intent, 0);
+ }
+
+ float rebase(float v, IPTestListJB.TestName t) {
+ if (v > 0.001) {
+ v = t.baseline / v;
+ }
+ float pr = (1920.f / mRes.width) * (1080.f / mRes.height);
+ return v / pr;
+ }
+
+ private void writeResults() {
+ // write result into a file
+ File externalStorage = Environment.getExternalStorageDirectory();
+ if (!externalStorage.canWrite()) {
+ Log.v(TAG, "sdcard is not writable");
+ return;
+ }
+ File resultFile = new File(externalStorage, RESULT_FILE);
+ resultFile.setWritable(true, false);
+ try {
+ BufferedWriter rsWriter = new BufferedWriter(new FileWriter(resultFile));
+ Log.v(TAG, "Saved results in: " + resultFile.getAbsolutePath());
+ java.text.DecimalFormat df = new java.text.DecimalFormat("######.##");
+
+ for (int ct=0; ct < IPTestListJB.TestName.values().length; ct++) {
+ IPTestListJB.TestName t = IPTestListJB.TestName.values()[ct];
+ final float r = mResults[ct];
+ float r2 = rebase(r, t);
+ String s = new String("" + t.toString() + ", " + df.format(r) + ", " + df.format(r2));
+ rsWriter.write(s + "\n");
+ }
+ rsWriter.close();
+ } catch (IOException e) {
+ Log.v(TAG, "Unable to write result file " + e.getMessage());
+ }
+ }
+
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == 0) {
+ if (resultCode == RESULT_OK) {
+ java.text.DecimalFormat df = new java.text.DecimalFormat("######.#");
+ mResults = new float[IPTestListJB.TestName.values().length];
+
+ float r[] = data.getFloatArrayExtra("results");
+ int id[] = data.getIntArrayExtra("tests");
+
+ for (int ct=0; ct < id.length; ct++) {
+ IPTestListJB.TestName t = IPTestListJB.TestName.values()[id[ct]];
+
+ String s = t.toString() + " " + df.format(rebase(r[ct], t)) +
+ "X, " + df.format(r[ct]) + "ms";
+ mTestList.set(id[ct], s);
+ mTestListAdapter.notifyDataSetChanged();
+ mResults[id[ct]] = r[ct];
+ }
+
+ double gm[] = {1.0, 1.0, 1.0};
+ double count[] = {0, 0, 0};
+ for (int ct=0; ct < IPTestListJB.TestName.values().length; ct++) {
+ IPTestListJB.TestName t = IPTestListJB.TestName.values()[ct];
+ gm[t.group] *= rebase(mResults[ct], t);
+ count[t.group] += 1.0;
+ }
+ gm[0] = java.lang.Math.pow(gm[0], 1.0 / count[0]);
+ gm[1] = java.lang.Math.pow(gm[1], 1.0 / count[1]);
+ gm[2] = java.lang.Math.pow(gm[2], 1.0 / count[2]);
+
+ String s = "Results: fp full=" + df.format(gm[0]) +
+ ", fp relaxed=" +df.format(gm[1]) +
+ ", intrinsics=" + df.format(gm[2]);
+ mResultView.setText(s);
+ writeResults();
+ }
+ }
+ }
+
+ public void btnSelAll(View v) {
+ IPTestListJB.TestName t[] = IPTestListJB.TestName.values();
+ for (int i=0; i < t.length; i++) {
+ mTestListView.setItemChecked(i, true);
+ }
+ }
+
+ public void btnSelNone(View v) {
+ checkGroup(-1);
+ }
+
+ public void btnSelHp(View v) {
+ checkGroup(0);
+ }
+
+ public void btnSelLp(View v) {
+ checkGroup(1);
+ }
+
+ public void btnSelIntrinsic(View v) {
+ checkGroup(2);
+ }
+
+
+
+}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPTestListJB.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPTestListJB.java
new file mode 100644
index 0000000..9ad827d
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPTestListJB.java
@@ -0,0 +1,178 @@
+/*
+ * 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.rs.imagejb;
+
+import android.app.Activity;
+import android.view.View;
+import android.util.Log;
+
+public class IPTestListJB {
+ private final String TAG = "Img";
+ public final String RESULT_FILE = "image_processing_result.csv";
+
+ public static final int FULL_FP = 0;
+ public static final int RELAXED_FP = 1;
+ public static final int INTRINSIC = 2;
+
+ /**
+ * Define enum type for test names
+ */
+ public enum TestName {
+ LEVELS_VEC3_RELAXED ("Levels Vec3 Relaxed", RELAXED_FP, 55.6f),
+ LEVELS_VEC4_RELAXED ("Levels Vec4 Relaxed", RELAXED_FP, 39.1f),
+ LEVELS_VEC3_FULL ("Levels Vec3 Full", FULL_FP, 57.4f),
+ LEVELS_VEC4_FULL ("Levels Vec4 Full", FULL_FP, 68.1f),
+ BLUR_RADIUS_25 ("Blur radius 25", RELAXED_FP, 1045.f),
+ INTRINSIC_BLUR_RADIUS_25 ("Intrinsic Blur radius 25", INTRINSIC, 643.f),
+ GREYSCALE ("Greyscale", RELAXED_FP, 38.3f),
+ GRAIN ("Grain", RELAXED_FP, 57.8f),
+ FISHEYE_FULL ("Fisheye Full", FULL_FP, 211.2f),
+ FISHEYE_RELAXED ("Fisheye Relaxed", RELAXED_FP, 198.1f),
+ FISHEYE_APPROXIMATE_FULL ("Fisheye Approximate Full", FULL_FP, 211.0f),
+ FISHEYE_APPROXIMATE_RELAXED ("Fisheye Approximate Relaxed", RELAXED_FP, 190.1f),
+ VIGNETTE_FULL ("Vignette Full", FULL_FP, 98.6f),
+ VIGNETTE_RELAXED ("Vignette Relaxed", RELAXED_FP, 110.7f),
+ VIGNETTE_APPROXIMATE_FULL ("Vignette Approximate Full", FULL_FP, 80.6f),
+ VIGNETTE_APPROXIMATE_RELAXED ("Vignette Approximate Relaxed", RELAXED_FP, 87.9f),
+ GROUP_TEST_EMULATED ("Group Test (emulated)", INTRINSIC, 37.81f),
+ GROUP_TEST_NATIVE ("Group Test (native)", INTRINSIC, 37.8f),
+ CONVOLVE_3X3 ("Convolve 3x3", RELAXED_FP, 62.1f),
+ INTRINSICS_CONVOLVE_3X3 ("Intrinsics Convolve 3x3", INTRINSIC, 24.5f),
+ COLOR_MATRIX ("ColorMatrix", RELAXED_FP, 25.5f),
+ INTRINSICS_COLOR_MATRIX ("Intrinsics ColorMatrix", INTRINSIC, 13.3f),
+ INTRINSICS_COLOR_MATRIX_GREY ("Intrinsics ColorMatrix Grey", INTRINSIC, 13.4f),
+ COPY ("Copy", RELAXED_FP, 25.6f),
+ CROSS_PROCESS_USING_LUT ("CrossProcess (using LUT)", INTRINSIC, 18.6f),
+ CONVOLVE_5X5 ("Convolve 5x5", RELAXED_FP, 215.8f),
+ INTRINSICS_CONVOLVE_5X5 ("Intrinsics Convolve 5x5", INTRINSIC, 29.8f),
+ MANDELBROT ("Mandelbrot", FULL_FP, 108.1f),
+ INTRINSICS_BLEND ("Intrinsics Blend", INTRINSIC, 94.2f),
+ INTRINSICS_BLUR_25G ("Intrinsics Blur 25 uchar", INTRINSIC, 173.3f),
+ VIBRANCE ("Vibrance", RELAXED_FP, 88.3f),
+ BW_FILTER ("BW Filter", RELAXED_FP, 69.7f),
+ SHADOWS ("Shadows", RELAXED_FP, 155.3f),
+ CONTRAST ("Contrast", RELAXED_FP, 27.0f),
+ EXPOSURE ("Exposure", RELAXED_FP, 64.7f),
+ WHITE_BALANCE ("White Balance", RELAXED_FP, 160.1f),
+ COLOR_CUBE ("Color Cube", RELAXED_FP, 85.3f),
+ COLOR_CUBE_3D_INTRINSIC ("Color Cube (3D LUT intrinsic)", INTRINSIC, 49.5f);
+
+
+ private final String name;
+ public final int group;
+ public final float baseline;
+
+ private TestName(String s, int g, float base) {
+ name = s;
+ group = g;
+ baseline = base;
+ }
+ private TestName(String s, int g) {
+ name = s;
+ group = g;
+ baseline = 1.f;
+ }
+
+ // return quoted string as displayed test name
+ public String toString() {
+ return name;
+ }
+ }
+
+ static TestBase newTest(TestName testName) {
+ switch(testName) {
+ case LEVELS_VEC3_RELAXED:
+ return new LevelsV4(false, false);
+ case LEVELS_VEC4_RELAXED:
+ return new LevelsV4(false, true);
+ case LEVELS_VEC3_FULL:
+ return new LevelsV4(true, false);
+ case LEVELS_VEC4_FULL:
+ return new LevelsV4(true, true);
+ case BLUR_RADIUS_25:
+ return new Blur25(false);
+ case INTRINSIC_BLUR_RADIUS_25:
+ return new Blur25(true);
+ case GREYSCALE:
+ return new Greyscale();
+ case GRAIN:
+ return new Grain();
+ case FISHEYE_FULL:
+ return new Fisheye(false, false);
+ case FISHEYE_RELAXED:
+ return new Fisheye(false, true);
+ case FISHEYE_APPROXIMATE_FULL:
+ return new Fisheye(true, false);
+ case FISHEYE_APPROXIMATE_RELAXED:
+ return new Fisheye(true, true);
+ case VIGNETTE_FULL:
+ return new Vignette(false, false);
+ case VIGNETTE_RELAXED:
+ return new Vignette(false, true);
+ case VIGNETTE_APPROXIMATE_FULL:
+ return new Vignette(true, false);
+ case VIGNETTE_APPROXIMATE_RELAXED:
+ return new Vignette(true, true);
+ case GROUP_TEST_EMULATED:
+ return new GroupTest(false);
+ case GROUP_TEST_NATIVE:
+ return new GroupTest(true);
+ case CONVOLVE_3X3:
+ return new Convolve3x3(false);
+ case INTRINSICS_CONVOLVE_3X3:
+ return new Convolve3x3(true);
+ case COLOR_MATRIX:
+ return new ColorMatrix(false, false);
+ case INTRINSICS_COLOR_MATRIX:
+ return new ColorMatrix(true, false);
+ case INTRINSICS_COLOR_MATRIX_GREY:
+ return new ColorMatrix(true, true);
+ case COPY:
+ return new Copy();
+ case CROSS_PROCESS_USING_LUT:
+ return new CrossProcess();
+ case CONVOLVE_5X5:
+ return new Convolve5x5(false);
+ case INTRINSICS_CONVOLVE_5X5:
+ return new Convolve5x5(true);
+ case MANDELBROT:
+ return new Mandelbrot();
+ case INTRINSICS_BLEND:
+ return new Blend();
+ case INTRINSICS_BLUR_25G:
+ return new Blur25G();
+ case VIBRANCE:
+ return new Vibrance();
+ case BW_FILTER:
+ return new BWFilter();
+ case SHADOWS:
+ return new Shadows();
+ case CONTRAST:
+ return new Contrast();
+ case EXPOSURE:
+ return new Exposure();
+ case WHITE_BALANCE:
+ return new WhiteBalance();
+ case COLOR_CUBE:
+ return new ColorCube(false);
+ case COLOR_CUBE_3D_INTRINSIC:
+ return new ColorCube(true);
+ }
+ return null;
+ }
+}
+
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/ImageProcessingActivityJB.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ImageProcessingActivityJB.java
index 93937ef..d9b35bc 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/ImageProcessingActivityJB.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/ImageProcessingActivityJB.java
@@ -17,20 +17,21 @@
package com.android.rs.imagejb;
import android.app.Activity;
+import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
-import android.graphics.BitmapFactory;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.view.SurfaceView;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
-import android.widget.ImageView;
import android.widget.SeekBar;
import android.widget.Spinner;
import android.widget.TextView;
import android.view.View;
+import android.view.TextureView;
+import android.view.Surface;
+import android.graphics.SurfaceTexture;
+import android.graphics.Point;
+
import android.util.Log;
import android.renderscript.ScriptC;
import android.renderscript.RenderScript;
@@ -39,79 +40,11 @@
import android.renderscript.Element;
import android.renderscript.Script;
-import android.os.Environment;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
public class ImageProcessingActivityJB extends Activity
- implements SeekBar.OnSeekBarChangeListener {
+ implements SeekBar.OnSeekBarChangeListener,
+ TextureView.SurfaceTextureListener {
private final String TAG = "Img";
- public final String RESULT_FILE = "image_processing_result.csv";
-
- RenderScript mRS;
- Allocation mInPixelsAllocation;
- Allocation mInPixelsAllocation2;
- Allocation mOutPixelsAllocation;
-
- /**
- * Define enum type for test names
- */
- public enum TestName {
- // totally there are 38 test cases
- LEVELS_VEC3_RELAXED ("Levels Vec3 Relaxed"),
- LEVELS_VEC4_RELAXED ("Levels Vec4 Relaxed"),
- LEVELS_VEC3_FULL ("Levels Vec3 Full"),
- LEVELS_VEC4_FULL ("Levels Vec4 Full"),
- BLUR_RADIUS_25 ("Blur radius 25"),
- INTRINSIC_BLUE_RADIUS_25 ("Intrinsic Blur radius 25"),
- GREYSCALE ("Greyscale"),
- GRAIN ("Grain"),
- FISHEYE_FULL ("Fisheye Full"),
- FISHEYE_RELAXED ("Fisheye Relaxed"),
- FISHEYE_APPROXIMATE_FULL ("Fisheye Approximate Full"),
- FISHEYE_APPROXIMATE_RELAXED ("Fisheye Approximate Relaxed"),
- VIGNETTE_FULL ("Vignette Full"),
- VIGNETTE_RELAXED ("Vignette Relaxed"),
- VIGNETTE_APPROXIMATE_FULL ("Vignette Approximate Full"),
- VIGNETTE_APPROXIMATE_RELAXED ("Vignette Approximate Relaxed"),
- GROUP_TEST_EMULATED ("Group Test (emulated)"),
- GROUP_TEST_NATIVE ("Group Test (native)"),
- CONVOLVE_3X3 ("Convolve 3x3"),
- INTRINSICS_CONVOLVE_3X3 ("Intrinsics Convolve 3x3"),
- COLOR_MATRIX ("ColorMatrix"),
- INTRINSICS_COLOR_MATRIX ("Intrinsics ColorMatrix"),
- INTRINSICS_COLOR_MATRIX_GREY ("Intrinsics ColorMatrix Grey"),
- COPY ("Copy"),
- CROSS_PROCESS_USING_LUT ("CrossProcess (using LUT)"),
- CONVOLVE_5X5 ("Convolve 5x5"),
- INTRINSICS_CONVOLVE_5X5 ("Intrinsics Convolve 5x5"),
- MANDELBROT ("Mandelbrot"),
- INTRINSICS_BLEND ("Intrinsics Blend"),
- VIBRANCE ("Vibrance"),
- BW_FILTER ("BW Filter"),
- SHADOWS ("Shadows"),
- CONTRAST ("Contrast"),
- EXPOSURE ("Exposure"),
- WHITE_BALANCE ("White Balance");
-
-
- private final String name;
-
- private TestName(String s) {
- name = s;
- }
-
- // return quoted string as displayed test name
- public String toString() {
- return name;
- }
- }
-
- Bitmap mBitmapIn;
- Bitmap mBitmapIn2;
- Bitmap mBitmapOut;
private Spinner mSpinner;
private SeekBar mBar1;
@@ -124,77 +57,366 @@
private TextView mText3;
private TextView mText4;
private TextView mText5;
+ private SizedTV mDisplayView;
- private float mSaturation = 1.0f;
+ private int mTestList[];
+ private float mTestResults[];
- private TextView mBenchmarkResult;
- private Spinner mTestSpinner;
+ private boolean mToggleIO;
+ private boolean mToggleDVFS;
+ private boolean mToggleLong;
+ private boolean mTogglePause;
+ private int mBitmapWidth;
+ private int mBitmapHeight;
- private SurfaceView mSurfaceView;
- private ImageView mDisplayView;
+ static public class SizedTV extends TextureView {
+ int mWidth;
+ int mHeight;
- private boolean mDoingBenchmark;
+ public SizedTV(android.content.Context c) {
+ super(c);
+ mWidth = 800;
+ mHeight = 450;
+ }
- private TestBase mTest;
- private int mRunCount;
+ public SizedTV(android.content.Context c, android.util.AttributeSet attrs) {
+ super(c, attrs);
+ mWidth = 800;
+ mHeight = 450;
+ }
- public void updateDisplay() {
- mHandler.sendMessage(Message.obtain());
+ public SizedTV(android.content.Context c, android.util.AttributeSet attrs, int f) {
+ super(c, attrs, f);
+ mWidth = 800;
+ mHeight = 450;
+ }
+
+ protected void onMeasure(int w, int h) {
+ setMeasuredDimension(mWidth, mHeight);
+ }
}
- private Handler mHandler = new Handler() {
- // Allow the filter to complete without blocking the UI
- // thread. When the message arrives that the op is complete
- // we will either mark completion or start a new filter if
- // more work is ready. Either way, display the result.
- @Override
- public void handleMessage(Message msg) {
- mTest.updateBitmap(mBitmapOut);
- mDisplayView.invalidate();
+ /////////////////////////////////////////////////////////////////////////
- boolean doTest = false;
- synchronized(this) {
- if (mRunCount > 0) {
- mRunCount--;
- if (mRunCount > 0) {
- doTest = true;
+ class Processor extends Thread {
+ RenderScript mRS;
+ Allocation mInPixelsAllocation;
+ Allocation mInPixelsAllocation2;
+ Allocation mOutDisplayAllocation;
+ Allocation mOutPixelsAllocation;
+
+ private Surface mOutSurface;
+ private float mLastResult;
+ private boolean mRun = true;
+ private int mOp = 0;
+ private boolean mDoingBenchmark;
+ private TestBase mTest;
+ private TextureView mDisplayView;
+
+ private boolean mBenchmarkMode;
+
+ Processor(RenderScript rs, TextureView v, boolean benchmarkMode) {
+ mRS = rs;
+ mDisplayView = v;
+
+ switch(mBitmapWidth) {
+ case 3840:
+ mInPixelsAllocation = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img3840x2160a);
+ mInPixelsAllocation2 = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img3840x2160b);
+ break;
+ case 1920:
+ mInPixelsAllocation = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1920x1080a);
+ mInPixelsAllocation2 = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1920x1080b);
+ break;
+ case 1280:
+ mInPixelsAllocation = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1280x720a);
+ mInPixelsAllocation2 = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img1280x720b);
+ break;
+ case 800:
+ mInPixelsAllocation = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img800x450a);
+ mInPixelsAllocation2 = Allocation.createFromBitmapResource(
+ mRS, getResources(), R.drawable.img800x450b);
+ break;
+ }
+
+ mOutDisplayAllocation = Allocation.createTyped(mRS, mInPixelsAllocation.getType(),
+ Allocation.MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_SCRIPT |
+ Allocation.USAGE_IO_OUTPUT);
+ mOutPixelsAllocation = mOutDisplayAllocation;
+
+ if (!mToggleIO) {
+ // Not using USAGE_IO for the script so create a non-io kernel to copy from
+ mOutPixelsAllocation = Allocation.createTyped(mRS, mInPixelsAllocation.getType(),
+ Allocation.MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_SCRIPT);
+ }
+
+ mBenchmarkMode = benchmarkMode;
+ start();
+ }
+
+ private float getBenchmark() {
+ mDoingBenchmark = true;
+
+ mTest.setupBenchmark();
+ long result = 0;
+ long runtime = 1000;
+ if (mToggleLong) {
+ runtime = 10000;
+ }
+
+ if (mToggleDVFS) {
+ mDvfsWar.go();
+ }
+
+ //Log.v("rs", "Warming");
+ long t = java.lang.System.currentTimeMillis() + 250;
+ do {
+ mTest.runTest();
+ mTest.finish();
+ } while (t > java.lang.System.currentTimeMillis());
+ //mHandler.sendMessage(Message.obtain());
+
+ //Log.v("rs", "Benchmarking");
+ int ct = 0;
+ t = java.lang.System.currentTimeMillis();
+ do {
+ mTest.runTest();
+ mTest.finish();
+ ct++;
+ } while ((t + runtime) > java.lang.System.currentTimeMillis());
+ t = java.lang.System.currentTimeMillis() - t;
+ float ft = (float)t;
+ ft /= ct;
+
+ mTest.exitBenchmark();
+ mDoingBenchmark = false;
+
+ android.util.Log.v("rs", "bench " + ft);
+ return ft;
+ }
+
+ private Handler mHandler = new Handler() {
+ // Allow the filter to complete without blocking the UI
+ // thread. When the message arrives that the op is complete
+ // we will either mark completion or start a new filter if
+ // more work is ready. Either way, display the result.
+ @Override
+ public void handleMessage(Message msg) {
+ synchronized(this) {
+ if (mRS == null || mOutPixelsAllocation == null) {
+ return;
}
+ if (mOutDisplayAllocation != mOutPixelsAllocation) {
+ mOutDisplayAllocation.copyFrom(mOutPixelsAllocation);
+ }
+ mOutDisplayAllocation.ioSend();
+ mDisplayView.invalidate();
+ //mTest.runTestSendMessage();
}
}
- if (doTest) {
- mTest.runTestSendMessage();
+ };
+
+ public void run() {
+ Surface lastSurface = null;
+ while (mRun) {
+ synchronized(this) {
+ try {
+ this.wait();
+ } catch(InterruptedException e) {
+ }
+ if (!mRun) return;
+
+ if ((mOutSurface == null) || (mOutPixelsAllocation == null)) {
+ continue;
+ }
+
+ if (lastSurface != mOutSurface) {
+ mOutDisplayAllocation.setSurface(mOutSurface);
+ lastSurface = mOutSurface;
+ }
+ }
+
+ if (mBenchmarkMode) {
+ for (int ct=0; (ct < mTestList.length) && mRun; ct++) {
+ mRS.finish();
+
+ try {
+ sleep(250);
+ } catch(InterruptedException e) {
+ }
+
+ if (mTest != null) {
+ mTest.destroy();
+ }
+
+ mTest = changeTest(mTestList[ct]);
+ if (mTogglePause) {
+ for (int i=0; (i < 100) && mRun; i++) {
+ try {
+ sleep(100);
+ } catch(InterruptedException e) {
+ }
+ }
+ }
+
+ mTestResults[ct] = getBenchmark();
+ mHandler.sendMessage(Message.obtain());
+ }
+ onBenchmarkFinish(mRun);
+ }
+ }
+
+ }
+
+ public void update() {
+ synchronized(this) {
+ if (mOp == 0) {
+ mOp = 2;
+ }
+ notifyAll();
}
}
+ public void setSurface(Surface s) {
+ synchronized(this) {
+ mOutSurface = s;
+ notifyAll();
+ }
+ //update();
+ }
+
+ public void exit() {
+ mRun = false;
+
+ synchronized(this) {
+ notifyAll();
+ }
+
+ try {
+ this.join();
+ } catch(InterruptedException e) {
+ }
+
+ mInPixelsAllocation.destroy();
+ mInPixelsAllocation2.destroy();
+ if (mOutPixelsAllocation != mOutDisplayAllocation) {
+ mOutPixelsAllocation.destroy();
+ }
+ mOutDisplayAllocation.destroy();
+ mRS.destroy();
+
+ mInPixelsAllocation = null;
+ mInPixelsAllocation2 = null;
+ mOutPixelsAllocation = null;
+ mOutDisplayAllocation = null;
+ mRS = null;
+ }
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////////////
+
+ static class DVFSWorkaround {
+ static class spinner extends Thread {
+ boolean mRun = true;
+ long mNextSleep;
+
+ spinner() {
+ setPriority(MIN_PRIORITY);
+ start();
+ }
+
+ public void run() {
+ while (mRun) {
+ Thread.yield();
+ synchronized(this) {
+ long t = java.lang.System.currentTimeMillis();
+ if (t > mNextSleep) {
+ try {
+ this.wait();
+ } catch(InterruptedException e) {
+ }
+ }
+ }
+ }
+ }
+
+ public void go(long t) {
+ synchronized(this) {
+ mNextSleep = t;
+ notifyAll();
+ }
+ }
+ }
+
+ spinner s1;
+ DVFSWorkaround() {
+ s1 = new spinner();
+ }
+
+ void go() {
+ long t = java.lang.System.currentTimeMillis() + 2000;
+ s1.go(t);
+ }
+
+ void destroy() {
+ synchronized(this) {
+ s1.mRun = false;
+ notifyAll();
+ }
+ }
+ }
+ DVFSWorkaround mDvfsWar = new DVFSWorkaround();
+
+ ///////////////////////////////////////////////////////////
+
+
+ private boolean mDoingBenchmark;
+ public Processor mProcessor;
+
+
+ private Handler mHandler = new Handler() {
+ @Override
+ public void handleMessage(Message msg) {
+ mDisplayView.invalidate();
+ }
};
+ public void updateDisplay() {
+ mHandler.sendMessage(Message.obtain());
+ //mProcessor.update();
+ }
+
+ TestBase changeTest(int id) {
+ IPTestListJB.TestName t = IPTestListJB.TestName.values()[id];
+ TestBase tb = IPTestListJB.newTest(t);
+ tb.createBaseTest(this);
+ //setupBars(tb);
+ return tb;
+ }
+
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
if (fromUser) {
-
if (seekBar == mBar1) {
- mTest.onBar1Changed(progress);
+ mProcessor.mTest.onBar1Changed(progress);
} else if (seekBar == mBar2) {
- mTest.onBar2Changed(progress);
+ mProcessor.mTest.onBar2Changed(progress);
} else if (seekBar == mBar3) {
- mTest.onBar3Changed(progress);
+ mProcessor.mTest.onBar3Changed(progress);
} else if (seekBar == mBar4) {
- mTest.onBar4Changed(progress);
+ mProcessor.mTest.onBar4Changed(progress);
} else if (seekBar == mBar5) {
- mTest.onBar5Changed(progress);
+ mProcessor.mTest.onBar5Changed(progress);
}
-
- boolean doTest = false;
- synchronized(this) {
- if (mRunCount == 0) {
- doTest = true;
- mRunCount = 1;
- } else {
- mRunCount = 2;
- }
- }
- if (doTest) {
- mTest.runTestSendMessage();
- }
+ mProcessor.update();
}
}
@@ -204,182 +426,56 @@
public void onStopTrackingTouch(SeekBar seekBar) {
}
- void setupBars() {
+ void setupBars(TestBase t) {
mSpinner.setVisibility(View.VISIBLE);
- mTest.onSpinner1Setup(mSpinner);
+ t.onSpinner1Setup(mSpinner);
mBar1.setVisibility(View.VISIBLE);
mText1.setVisibility(View.VISIBLE);
- mTest.onBar1Setup(mBar1, mText1);
+ t.onBar1Setup(mBar1, mText1);
mBar2.setVisibility(View.VISIBLE);
mText2.setVisibility(View.VISIBLE);
- mTest.onBar2Setup(mBar2, mText2);
+ t.onBar2Setup(mBar2, mText2);
mBar3.setVisibility(View.VISIBLE);
mText3.setVisibility(View.VISIBLE);
- mTest.onBar3Setup(mBar3, mText3);
+ t.onBar3Setup(mBar3, mText3);
mBar4.setVisibility(View.VISIBLE);
mText4.setVisibility(View.VISIBLE);
- mTest.onBar4Setup(mBar4, mText4);
+ t.onBar4Setup(mBar4, mText4);
mBar5.setVisibility(View.VISIBLE);
mText5.setVisibility(View.VISIBLE);
- mTest.onBar5Setup(mBar5, mText5);
+ t.onBar5Setup(mBar5, mText5);
}
+ void hideBars() {
+ mSpinner.setVisibility(View.INVISIBLE);
- void changeTest(TestName testName) {
- if (mTest != null) {
- mTest.destroy();
- }
- switch(testName) {
- case LEVELS_VEC3_RELAXED:
- mTest = new LevelsV4(false, false);
- break;
- case LEVELS_VEC4_RELAXED:
- mTest = new LevelsV4(false, true);
- break;
- case LEVELS_VEC3_FULL:
- mTest = new LevelsV4(true, false);
- break;
- case LEVELS_VEC4_FULL:
- mTest = new LevelsV4(true, true);
- break;
- case BLUR_RADIUS_25:
- mTest = new Blur25(false);
- break;
- case INTRINSIC_BLUE_RADIUS_25:
- mTest = new Blur25(true);
- break;
- case GREYSCALE:
- mTest = new Greyscale();
- break;
- case GRAIN:
- mTest = new Grain();
- break;
- case FISHEYE_FULL:
- mTest = new Fisheye(false, false);
- break;
- case FISHEYE_RELAXED:
- mTest = new Fisheye(false, true);
- break;
- case FISHEYE_APPROXIMATE_FULL:
- mTest = new Fisheye(true, false);
- break;
- case FISHEYE_APPROXIMATE_RELAXED:
- mTest = new Fisheye(true, true);
- break;
- case VIGNETTE_FULL:
- mTest = new Vignette(false, false);
- break;
- case VIGNETTE_RELAXED:
- mTest = new Vignette(false, true);
- break;
- case VIGNETTE_APPROXIMATE_FULL:
- mTest = new Vignette(true, false);
- break;
- case VIGNETTE_APPROXIMATE_RELAXED:
- mTest = new Vignette(true, true);
- break;
- case GROUP_TEST_EMULATED:
- mTest = new GroupTest(false);
- break;
- case GROUP_TEST_NATIVE:
- mTest = new GroupTest(true);
- break;
- case CONVOLVE_3X3:
- mTest = new Convolve3x3(false);
- break;
- case INTRINSICS_CONVOLVE_3X3:
- mTest = new Convolve3x3(true);
- break;
- case COLOR_MATRIX:
- mTest = new ColorMatrix(false, false);
- break;
- case INTRINSICS_COLOR_MATRIX:
- mTest = new ColorMatrix(true, false);
- break;
- case INTRINSICS_COLOR_MATRIX_GREY:
- mTest = new ColorMatrix(true, true);
- break;
- case COPY:
- mTest = new Copy();
- break;
- case CROSS_PROCESS_USING_LUT:
- mTest = new CrossProcess();
- break;
- case CONVOLVE_5X5:
- mTest = new Convolve5x5(false);
- break;
- case INTRINSICS_CONVOLVE_5X5:
- mTest = new Convolve5x5(true);
- break;
- case MANDELBROT:
- mTest = new Mandelbrot();
- break;
- case INTRINSICS_BLEND:
- mTest = new Blend();
- break;
- case VIBRANCE:
- mTest = new Vibrance();
- break;
- case BW_FILTER:
- mTest = new BWFilter();
- break;
- case SHADOWS:
- mTest = new Shadows();
- break;
- case CONTRAST:
- mTest = new Contrast();
- break;
- case EXPOSURE:
- mTest = new Exposure();
- break;
- case WHITE_BALANCE:
- mTest = new WhiteBalance();
- break;
- }
+ mBar1.setVisibility(View.INVISIBLE);
+ mText1.setVisibility(View.INVISIBLE);
- mTest.createBaseTest(this, mBitmapIn, mBitmapIn2, mBitmapOut);
- setupBars();
+ mBar2.setVisibility(View.INVISIBLE);
+ mText2.setVisibility(View.INVISIBLE);
- mTest.runTest();
- updateDisplay();
- mBenchmarkResult.setText("Result: not run");
+ mBar3.setVisibility(View.INVISIBLE);
+ mText3.setVisibility(View.INVISIBLE);
+
+ mBar4.setVisibility(View.INVISIBLE);
+ mText4.setVisibility(View.INVISIBLE);
+
+ mBar5.setVisibility(View.INVISIBLE);
+ mText5.setVisibility(View.INVISIBLE);
}
- void setupTests() {
- mTestSpinner.setAdapter(new ArrayAdapter<TestName>(
- this, R.layout.spinner_layout, TestName.values()));
- }
-
- private AdapterView.OnItemSelectedListener mTestSpinnerListener =
- new AdapterView.OnItemSelectedListener() {
- public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
- changeTest(TestName.values()[pos]);
- }
-
- public void onNothingSelected(AdapterView parent) {
-
- }
- };
-
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
- mBitmapIn = loadBitmap(R.drawable.img1600x1067);
- mBitmapIn2 = loadBitmap(R.drawable.img1600x1067b);
- mBitmapOut = Bitmap.createBitmap(mBitmapIn.getWidth(), mBitmapIn.getHeight(),
- mBitmapIn.getConfig());
-
- mSurfaceView = (SurfaceView) findViewById(R.id.surface);
-
- mDisplayView = (ImageView) findViewById(R.id.display);
- mDisplayView.setImageBitmap(mBitmapOut);
+ mDisplayView = (SizedTV) findViewById(R.id.display);
mSpinner = (Spinner) findViewById(R.id.spinner1);
@@ -400,95 +496,97 @@
mText3 = (TextView) findViewById(R.id.slider3Text);
mText4 = (TextView) findViewById(R.id.slider4Text);
mText5 = (TextView) findViewById(R.id.slider5Text);
-
- mTestSpinner = (Spinner) findViewById(R.id.filterselection);
- mTestSpinner.setOnItemSelectedListener(mTestSpinnerListener);
-
- mBenchmarkResult = (TextView) findViewById(R.id.benchmarkText);
- mBenchmarkResult.setText("Result: not run");
-
-
- mRS = RenderScript.create(this);
- mInPixelsAllocation = Allocation.createFromBitmap(mRS, mBitmapIn);
- mInPixelsAllocation2 = Allocation.createFromBitmap(mRS, mBitmapIn2);
- mOutPixelsAllocation = Allocation.createFromBitmap(mRS, mBitmapOut);
-
-
- setupTests();
- changeTest(TestName.LEVELS_VEC3_RELAXED);
}
-
- private Bitmap loadBitmap(int resource) {
- final BitmapFactory.Options options = new BitmapFactory.Options();
- options.inPreferredConfig = Bitmap.Config.ARGB_8888;
- return BitmapFactory.decodeResource(getResources(), resource, options);
+ @Override
+ protected void onPause() {
+ super.onPause();
+ mProcessor.exit();
}
- // button hook
- public void benchmark(View v) {
- float t = getBenchmark();
- //long javaTime = javaFilter();
- //mBenchmarkResult.setText("RS: " + t + " ms Java: " + javaTime + " ms");
- mBenchmarkResult.setText("Result: " + t + " ms");
- Log.v(TAG, "getBenchmark: Renderscript frame time core ms " + t);
- }
-
- public void benchmark_all(View v) {
- // write result into a file
- File externalStorage = Environment.getExternalStorageDirectory();
- if (!externalStorage.canWrite()) {
- Log.v(TAG, "sdcard is not writable");
- return;
+ public void onBenchmarkFinish(boolean ok) {
+ if (ok) {
+ Intent intent = new Intent();
+ intent.putExtra("tests", mTestList);
+ intent.putExtra("results", mTestResults);
+ setResult(RESULT_OK, intent);
+ } else {
+ setResult(RESULT_CANCELED);
}
- File resultFile = new File(externalStorage, RESULT_FILE);
- resultFile.setWritable(true, false);
- try {
- BufferedWriter rsWriter = new BufferedWriter(new FileWriter(resultFile));
- Log.v(TAG, "Saved results in: " + resultFile.getAbsolutePath());
- for (TestName tn: TestName.values()) {
- changeTest(tn);
- float t = getBenchmark();
- String s = new String("" + tn.toString() + ", " + t);
- rsWriter.write(s + "\n");
- Log.v(TAG, "Test " + s + "ms\n");
+ finish();
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ Intent i = getIntent();
+ mTestList = i.getIntArrayExtra("tests");
+
+ mToggleIO = i.getBooleanExtra("enable io", false);
+ mToggleDVFS = i.getBooleanExtra("enable dvfs", true);
+ mToggleLong = i.getBooleanExtra("enable long", false);
+ mTogglePause = i.getBooleanExtra("enable pause", false);
+ mBitmapWidth = i.getIntExtra("resolution X", 0);
+ mBitmapHeight = i.getIntExtra("resolution Y", 0);
+
+ mTestResults = new float[mTestList.length];
+
+ hideBars();
+
+ Point size = new Point();
+ getWindowManager().getDefaultDisplay().getSize(size);
+
+ int mScreenWidth = size.x;
+ int mScreenHeight = size.y;
+
+ int tw = mBitmapWidth;
+ int th = mBitmapHeight;
+
+ if (tw > mScreenWidth || th > mScreenHeight) {
+ float s1 = (float)tw / (float)mScreenWidth;
+ float s2 = (float)th / (float)mScreenHeight;
+
+ if (s1 > s2) {
+ tw /= s1;
+ th /= s1;
+ } else {
+ tw /= s2;
+ th /= s2;
}
- rsWriter.close();
- } catch (IOException e) {
- Log.v(TAG, "Unable to write result file " + e.getMessage());
}
- changeTest(TestName.LEVELS_VEC3_RELAXED);
+
+ android.util.Log.v("rs", "TV sizes " + tw + ", " + th);
+
+ mDisplayView.mWidth = tw;
+ mDisplayView.mHeight = th;
+ //mDisplayView.setTransform(new android.graphics.Matrix());
+
+ mProcessor = new Processor(RenderScript.create(this), mDisplayView, true);
+ mDisplayView.setSurfaceTextureListener(this);
}
- // For benchmark test
- public float getBenchmark() {
- mDoingBenchmark = true;
+ protected void onDestroy() {
+ super.onDestroy();
+ }
- mTest.setupBenchmark();
- long result = 0;
- //Log.v(TAG, "Warming");
- long t = java.lang.System.currentTimeMillis() + 250;
- do {
- mTest.runTest();
- mTest.finish();
- } while (t > java.lang.System.currentTimeMillis());
+ @Override
+ public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+ mProcessor.setSurface(new Surface(surface));
+ }
- //Log.v(TAG, "Benchmarking");
- int ct = 0;
- t = java.lang.System.currentTimeMillis();
- do {
- mTest.runTest();
- mTest.finish();
- ct++;
- } while ((t+1000) > java.lang.System.currentTimeMillis());
- t = java.lang.System.currentTimeMillis() - t;
- float ft = (float)t;
- ft /= ct;
+ @Override
+ public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+ mProcessor.setSurface(new Surface(surface));
+ }
- mTest.exitBenchmark();
- mDoingBenchmark = false;
+ @Override
+ public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+ mProcessor.setSurface(null);
+ return true;
+ }
- return ft;
+ @Override
+ public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/LevelsV4.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/LevelsV4.java
index 741e480..ba08b54 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/LevelsV4.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/LevelsV4.java
@@ -109,7 +109,7 @@
public boolean onBar4Setup(SeekBar b, TextView t) {
b.setMax(128);
b.setProgress(128);
- t.setText("Out White");
+ t.setText("In White");
return true;
}
public boolean onBar5Setup(SeekBar b, TextView t) {
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/TestBase.java b/java/tests/ImageProcessing_jb/src/com/android/rs/image/TestBase.java
index 9ae366a..3de9809 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/TestBase.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/TestBase.java
@@ -45,8 +45,6 @@
protected Allocation mInPixelsAllocation;
protected Allocation mInPixelsAllocation2;
protected Allocation mOutPixelsAllocation;
- protected ScriptC_msg mMessageScript;
-
protected ImageProcessingActivityJB act;
private class MessageProcessor extends RenderScript.RSMessageHandler {
@@ -106,14 +104,14 @@
return false;
}
- public final void createBaseTest(ImageProcessingActivityJB ipact, Bitmap b, Bitmap b2, Bitmap outb) {
+ public final void createBaseTest(ImageProcessingActivityJB ipact) {
act = ipact;
- mRS = ipact.mRS;
+ mRS = ipact.mProcessor.mRS;
mRS.setMessageHandler(new MessageProcessor(act));
- mInPixelsAllocation = ipact.mInPixelsAllocation;
- mInPixelsAllocation2 = ipact.mInPixelsAllocation2;
- mOutPixelsAllocation = ipact.mOutPixelsAllocation;
+ mInPixelsAllocation = ipact.mProcessor.mInPixelsAllocation;
+ mInPixelsAllocation2 = ipact.mProcessor.mInPixelsAllocation2;
+ mOutPixelsAllocation = ipact.mProcessor.mOutPixelsAllocation;
createTest(act.getResources());
}
@@ -128,7 +126,7 @@
final public void runTestSendMessage() {
runTest();
- mMessageScript.invoke_sendMsg();
+ mRS.sendMessage(0, null);
}
public void finish() {
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/blend.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/blend.rs
index 9ec1246..63e7ea5 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/blend.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/blend.rs
@@ -13,6 +13,7 @@
// limitations under the License.
#include "ip.rsh"
+#pragma rs_fp_relaxed
uchar alpha = 0x0;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/bwfilter.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/bwfilter.rs
index e706d44..e211620 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/bwfilter.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/bwfilter.rs
@@ -15,7 +15,7 @@
*/
#include "ip.rsh"
-//#pragma rs_fp_relaxed
+#pragma rs_fp_relaxed
static float sr = 0.f;
static float sg = 0.f;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/colorcube.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/colorcube.rs
new file mode 100644
index 0000000..c0d6ace
--- /dev/null
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/colorcube.rs
@@ -0,0 +1,89 @@
+/*
+ * 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.
+ */
+
+#include "ip.rsh"
+#pragma rs_fp_relaxed
+
+
+static rs_allocation gCube;
+static int4 gDims;
+static int4 gCoordMul;
+
+
+void setCube(rs_allocation c) {
+ gCube = c;
+ gDims.x = rsAllocationGetDimX(gCube);
+ gDims.y = rsAllocationGetDimY(gCube);
+ gDims.z = rsAllocationGetDimZ(gCube);
+ gDims.w = 0;
+
+ float4 m = (float4)(1.f / 255.f) * convert_float4(gDims - 1);
+ gCoordMul = convert_int4(m * (float4)0x10000);
+
+ rsDebug("dims", gDims);
+ rsDebug("gCoordMul", gCoordMul);
+}
+
+void root(const uchar4 *in, uchar4 *out, uint32_t x, uint32_t y) {
+ //rsDebug("root", in);
+
+ int4 baseCoord = convert_int4(*in) * gCoordMul;
+ int4 coord1 = baseCoord >> (int4)16;
+ int4 coord2 = min(coord1 + 1, gDims - 1);
+
+ int4 weight2 = baseCoord & 0xffff;
+ int4 weight1 = (int4)0x10000 - weight2;
+
+ uint4 v000 = convert_uint4(rsGetElementAt_uchar4(gCube, coord1.x, coord1.y, coord1.z));
+ uint4 v100 = convert_uint4(rsGetElementAt_uchar4(gCube, coord2.x, coord1.y, coord1.z));
+ uint4 v010 = convert_uint4(rsGetElementAt_uchar4(gCube, coord1.x, coord2.y, coord1.z));
+ uint4 v110 = convert_uint4(rsGetElementAt_uchar4(gCube, coord2.x, coord2.y, coord1.z));
+ uint4 v001 = convert_uint4(rsGetElementAt_uchar4(gCube, coord1.x, coord1.y, coord2.z));
+ uint4 v101 = convert_uint4(rsGetElementAt_uchar4(gCube, coord2.x, coord1.y, coord2.z));
+ uint4 v011 = convert_uint4(rsGetElementAt_uchar4(gCube, coord1.x, coord2.y, coord2.z));
+ uint4 v111 = convert_uint4(rsGetElementAt_uchar4(gCube, coord2.x, coord2.y, coord2.z));
+
+ uint4 yz00 = ((v000 * weight1.x) + (v100 * weight2.x)) >> (uint4)8;
+ uint4 yz10 = ((v010 * weight1.x) + (v110 * weight2.x)) >> (uint4)8;
+ uint4 yz01 = ((v001 * weight1.x) + (v101 * weight2.x)) >> (uint4)8;
+ uint4 yz11 = ((v011 * weight1.x) + (v111 * weight2.x)) >> (uint4)8;
+
+ uint4 z0 = ((yz00 * weight1.y) + (yz10 * weight2.y)) >> (uint4)16;
+ uint4 z1 = ((yz01 * weight1.y) + (yz11 * weight2.y)) >> (uint4)16;
+
+ uint4 v = ((z0 * weight1.z) + (z1 * weight2.z)) >> (uint4)16;
+ uint4 v2 = (v + 0x7f) >> (uint4)8;
+
+ *out = convert_uchar4(v2);
+ out->a = 0xff;
+
+ #if 0
+ if (in->r != out->r) {
+ rsDebug("dr", in->r - out->r);
+ //rsDebug("in", convert_int4(*in));
+ //rsDebug("coord1", coord1);
+ //rsDebug("coord2", coord2);
+ //rsDebug("weight1", weight1);
+ //rsDebug("weight2", weight2);
+ //rsDebug("yz00", yz00);
+ //rsDebug("z0", z0);
+ //rsDebug("v", v);
+ //rsDebug("v2", v2);
+ //rsDebug("out", convert_int4(*out));
+ }
+ #endif
+}
+
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/contrast.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/contrast.rs
index d3743d3..ef6fd63 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/contrast.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/contrast.rs
@@ -15,6 +15,7 @@
*/
#include "ip.rsh"
+#pragma rs_fp_relaxed
static float brightM = 0.f;
static float brightC = 0.f;
@@ -26,12 +27,6 @@
void contrast(const uchar4 *in, uchar4 *out)
{
-#if 0
- out->r = rsClamp((int)(brightM * in->r + brightC), 0, 255);
- out->g = rsClamp((int)(brightM * in->g + brightC), 0, 255);
- out->b = rsClamp((int)(brightM * in->b + brightC), 0, 255);
-#else
float3 v = convert_float3(in->rgb) * brightM + brightC;
out->rgb = convert_uchar3(clamp(v, 0.f, 255.f));
-#endif
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/convolve3x3.fs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/convolve3x3.fs
index 177e86e..4f8b4d8 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/convolve3x3.fs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/convolve3x3.fs
@@ -28,6 +28,8 @@
uint32_t y1 = min((int32_t)y+1, gHeight-1);
uint32_t y2 = max((int32_t)y-1, 0);
+ float4 result;
+
float4 p00 = convert_float4(rsGetElementAt_uchar4(gIn, x1, y1));
float4 p01 = convert_float4(rsGetElementAt_uchar4(gIn, x, y1));
float4 p02 = convert_float4(rsGetElementAt_uchar4(gIn, x2, y1));
@@ -37,29 +39,19 @@
float4 p20 = convert_float4(rsGetElementAt_uchar4(gIn, x1, y2));
float4 p21 = convert_float4(rsGetElementAt_uchar4(gIn, x, y2));
float4 p22 = convert_float4(rsGetElementAt_uchar4(gIn, x2, y2));
- p00 *= gCoeffs[0];
- p01 *= gCoeffs[1];
- p02 *= gCoeffs[2];
- p10 *= gCoeffs[3];
- p11 *= gCoeffs[4];
- p12 *= gCoeffs[5];
- p20 *= gCoeffs[6];
- p21 *= gCoeffs[7];
- p22 *= gCoeffs[8];
- p00 += p01;
- p02 += p10;
- p11 += p12;
- p20 += p21;
+ result = p00 * gCoeffs[0];
+ result += p01 * gCoeffs[1];
+ result += p02 * gCoeffs[2];
+ result += p10 * gCoeffs[3];
+ result += p11 * gCoeffs[4];
+ result += p12 * gCoeffs[5];
+ result += p20 * gCoeffs[6];
+ result += p21 * gCoeffs[7];
+ result += p22 * gCoeffs[8];
- p22 += p00;
- p02 += p11;
-
- p20 += p22;
- p20 += p02;
-
- p20 = clamp(p20, 0.f, 255.f);
- return convert_uchar4(p20);
+ result = clamp(result, 0.f, 255.f);
+ return convert_uchar4(result);
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/exposure.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/exposure.rs
index 0f05cb9..b937f70 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/exposure.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/exposure.rs
@@ -15,6 +15,7 @@
*/
#include "ip.rsh"
+#pragma rs_fp_relaxed
static float bright = 0.f;
@@ -22,10 +23,12 @@
bright = 255.f / (255.f - v);
}
-void exposure(const uchar4 *in, uchar4 *out)
+uchar4 __attribute__((kernel)) exposure(uchar4 in)
{
- out->r = rsClamp((int)(bright * in->r), 0, 255);
- out->g = rsClamp((int)(bright * in->g), 0, 255);
- out->b = rsClamp((int)(bright * in->b), 0, 255);
+ uchar4 out = 0;
+ out.r = rsClamp((int)(bright * in.r), 0, 255);
+ out.g = rsClamp((int)(bright * in.g), 0, 255);
+ out.b = rsClamp((int)(bright * in.b), 0, 255);
+ return out;
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/msg.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/msg.rs
deleted file mode 100644
index 645eb98..0000000
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/msg.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * 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.
- */
-
-#pragma version(1)
-#pragma rs java_package_name(com.android.rs.imagejb)
-
-void sendMsg() {
- rsSendToClientBlocking(0);
-}
-
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/shadows.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/shadows.rs
index f6c149d..107fd3a 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/shadows.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/shadows.rs
@@ -15,20 +15,20 @@
*/
#include "ip.rsh"
-//#pragma rs_fp_relaxed
+#pragma rs_fp_relaxed
-static double shadowFilterMap[] = {
- -0.00591, 0.0001,
- 1.16488, 0.01668,
- -0.18027, -0.06791,
- -0.12625, 0.09001,
- 0.15065, -0.03897
+static float shadowFilterMap[] = {
+ -0.00591f, 0.0001f,
+ 1.16488f, 0.01668f,
+ -0.18027f, -0.06791f,
+ -0.12625f, 0.09001f,
+ 0.15065f, -0.03897f
};
-static double poly[] = {
- 0., 0.,
- 0., 0.,
- 0.
+static float poly[] = {
+ 0.f, 0.f,
+ 0.f, 0.f,
+ 0.f
};
static const int ABITS = 4;
@@ -36,10 +36,10 @@
static const int k1=255 << ABITS;
static const int k2=HSCALE << ABITS;
-static double fastevalPoly(double *poly,int n, double x){
+static float fastevalPoly(float *poly,int n, float x){
- double f =x;
- double sum = poly[0]+poly[1]*f;
+ float f =x;
+ float sum = poly[0]+poly[1]*f;
int i;
for (i = 2; i < n; i++) {
f*=x;
@@ -177,7 +177,7 @@
}
void prepareShadows(float scale) {
- double s = (scale>=0)?scale:scale/5;
+ float s = (scale>=0) ? scale : scale / 5.f;
for (int i = 0; i < 5; i++) {
poly[i] = fastevalPoly(shadowFilterMap+i*2,2 , s);
}
@@ -185,8 +185,7 @@
void shadowsKernel(const uchar4 *in, uchar4 *out) {
ushort3 hsv = rgb2hsv(*in);
- double v = (fastevalPoly(poly,5,hsv.x/4080.)*4080);
- if (v>4080) v = 4080;
- hsv.x = (unsigned short) ((v>0)?v:0);
+ float v = (fastevalPoly(poly, 5, hsv.x * (1.f / 4080.f)) * 4080.f);
+ hsv.x = (unsigned short) clamp(v, 0.f, 4080.f);
*out = hsv2rgb(hsv);
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/vibrance.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/vibrance.rs
index 8db113c..b82e1d3 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/vibrance.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/vibrance.rs
@@ -15,6 +15,7 @@
*/
#include "ip.rsh"
+#pragma rs_fp_relaxed
float vibrance = 0.f;
@@ -22,11 +23,6 @@
static const float Gf = 0.587f;
static const float Bf = 0.114f;
-static float S = 0.f;
-static float MS = 0.f;
-static float Rt = 0.f;
-static float Gt = 0.f;
-static float Bt = 0.f;
static float Vib = 0.f;
void vibranceKernel(const uchar4 *in, uchar4 *out) {
@@ -36,14 +32,13 @@
int r = in->r;
int g = in->g;
int b = in->b;
- float red = (r-max(g, b))/256.f;
- float sx = (float)(Vib/(1+exp(-red*3)));
- S = sx+1;
- MS = 1.0f - S;
- Rt = Rf * MS;
- Gt = Gf * MS;
- Bt = Bf * MS;
- int t = (r + g) / 2;
+ float red = (r-max(g, b)) * (1.f / 256.f);
+ float S = (float)(Vib/(1+native_exp(-red*3)))+1;
+ float MS = 1.0f - S;
+ float Rt = Rf * MS;
+ float Gt = Gf * MS;
+ float Bt = Bf * MS;
+ int t = (r + g) >> 1;
R = r;
G = g;
B = b;
@@ -59,12 +54,5 @@
}
void prepareVibrance() {
-
Vib = vibrance/100.f;
- S = Vib + 1;
- MS = 1.0f - S;
- Rt = Rf * MS;
- Gt = Gf * MS;
- Bt = Bf * MS;
-
}
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/vignette_approx.rsh b/java/tests/ImageProcessing_jb/src/com/android/rs/image/vignette_approx.rsh
index 0eacdc8..5668621 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/vignette_approx.rsh
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/vignette_approx.rsh
@@ -50,7 +50,7 @@
const float2 inCoord = {(float)x, (float)y};
const float2 coord = mad(inCoord, inv_dimensions, neg_center);
const float sloped_dist_ratio = fast_length(axis_scale * coord) * sloped_inv_max_dist;
- const float lumen = opp_shade + shade * half_recip(1.f + sloped_neg_range * exp(sloped_dist_ratio));
+ const float lumen = opp_shade + shade * half_recip(1.f + sloped_neg_range * native_exp(sloped_dist_ratio));
float4 fout;
fout.rgb = fin.rgb * lumen;
fout.w = fin.w;
diff --git a/java/tests/ImageProcessing_jb/src/com/android/rs/image/wbalance.rs b/java/tests/ImageProcessing_jb/src/com/android/rs/image/wbalance.rs
index 6650671..b5ab14f 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/wbalance.rs
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/wbalance.rs
@@ -15,7 +15,7 @@
*/
#include "ip.rsh"
-//#pragma rs_fp_relaxed
+#pragma rs_fp_relaxed
static int histR[256] = {0}, histG[256] = {0}, histB[256] = {0};
diff --git a/java/tests/LivePreview/src/com/android/rs/livepreview/RsYuv.java b/java/tests/LivePreview/src/com/android/rs/livepreview/RsYuv.java
index 12d3185..15cd72a 100644
--- a/java/tests/LivePreview/src/com/android/rs/livepreview/RsYuv.java
+++ b/java/tests/LivePreview/src/com/android/rs/livepreview/RsYuv.java
@@ -27,6 +27,7 @@
import android.renderscript.RenderScript;
import android.util.Log;
import android.view.TextureView;
+import android.view.Surface;
import android.view.View;
import android.content.res.Resources;
@@ -44,7 +45,7 @@
private ScriptC_yuv mScript;
private ScriptIntrinsicYuvToRGB mYuv;
private boolean mHaveSurface;
- private SurfaceTexture mSurface;
+ private Surface mSurface;
private ScriptGroup mGroup;
RsYuv(RenderScript rs) {
@@ -55,7 +56,7 @@
void setupSurface() {
if (mAllocationOut != null) {
- mAllocationOut.setSurfaceTexture(mSurface);
+ mAllocationOut.setSurface(mSurface);
}
if (mSurface != null) {
mHaveSurface = true;
@@ -116,7 +117,7 @@
//mYuv.forEach(mAllocationOut);
//mScript.forEach_root(mAllocationOut, mAllocationOut);
- mAllocationOut.ioSendOutput();
+ mAllocationOut.ioSend();
}
}
@@ -125,21 +126,21 @@
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
android.util.Log.v("cpa", "onSurfaceTextureAvailable " + surface);
- mSurface = surface;
+ mSurface = new Surface(surface);
setupSurface();
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
android.util.Log.v("cpa", "onSurfaceTextureSizeChanged " + surface);
- mSurface = surface;
+ mSurface = new Surface(surface);
setupSurface();
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
android.util.Log.v("cpa", "onSurfaceTextureDestroyed " + surface);
- mSurface = surface;
+ mSurface = null;
setupSurface();
return true;
}
diff --git a/java/tests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java b/java/tests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java
index dd4a98a..feaa81d 100644
--- a/java/tests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java
+++ b/java/tests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java
@@ -157,7 +157,7 @@
long t = java.lang.System.currentTimeMillis();
mScript.invoke_setSampleData(alloc, mTwoByTwoAlloc, sampler);
mScript.forEach_root(alloc);
- alloc.ioSendOutput();
+ alloc.ioSend();
mRS.finish();
t = java.lang.System.currentTimeMillis() - t;
Log.i(TAG, "Filter time is: " + t + " ms");
diff --git a/tests/cppallocation/Android.mk b/tests/cppallocation/Android.mk
index 191c58d..ddd3ee1 100644
--- a/tests/cppallocation/Android.mk
+++ b/tests/cppallocation/Android.mk
@@ -30,6 +30,7 @@
LOCAL_C_INCLUDES += frameworks/rs
LOCAL_C_INCLUDES += $(intermediates)
+LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
diff --git a/tests/cppbasic/Android.mk b/tests/cppbasic/Android.mk
index bf7725a..3b19db7 100644
--- a/tests/cppbasic/Android.mk
+++ b/tests/cppbasic/Android.mk
@@ -30,6 +30,7 @@
LOCAL_C_INCLUDES += frameworks/rs
LOCAL_C_INCLUDES += $(intermediates)
+LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
diff --git a/tests/cppbasic/compute.cpp b/tests/cppbasic/compute.cpp
index 21ffe2b..d977667 100644
--- a/tests/cppbasic/compute.cpp
+++ b/tests/cppbasic/compute.cpp
@@ -6,7 +6,7 @@
using namespace android;
using namespace RSC;
-int main(int argc, char** argv)
+int main()
{
sp<RS> rs = new RS();
diff --git a/tests/cppstrided/Android.mk b/tests/cppstrided/Android.mk
index f0c5c4b..66161c4 100644
--- a/tests/cppstrided/Android.mk
+++ b/tests/cppstrided/Android.mk
@@ -30,6 +30,7 @@
LOCAL_C_INCLUDES += frameworks/rs
LOCAL_C_INCLUDES += $(intermediates)
+LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
diff --git a/tests/latency/Android.mk b/tests/latency/Android.mk
index cdea381..83d5ad8 100644
--- a/tests/latency/Android.mk
+++ b/tests/latency/Android.mk
@@ -30,6 +30,7 @@
LOCAL_C_INCLUDES += frameworks/rs
LOCAL_C_INCLUDES += $(intermediates)
+LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
diff --git a/tests/typecheck/Android.mk b/tests/typecheck/Android.mk
index 064ccc0..62522a4 100644
--- a/tests/typecheck/Android.mk
+++ b/tests/typecheck/Android.mk
@@ -30,6 +30,7 @@
LOCAL_C_INCLUDES += frameworks/rs
LOCAL_C_INCLUDES += $(intermediates)
+LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
diff --git a/tests/typecheck/typecheck.cpp b/tests/typecheck/typecheck.cpp
index 17dee1f..d50cbf6 100644
--- a/tests/typecheck/typecheck.cpp
+++ b/tests/typecheck/typecheck.cpp
@@ -71,7 +71,7 @@
TEST_ELEM_ALL(F32)
TEST_ELEM_ALL(F64)
-int main(int argc, char** argv)
+int main()
{
bool failed = false;
