Update IP_JB to support multiple image sizes.

Change-Id: I69a65bac112d629b32ce87199390378da1625485

4 files changed, 237 insertions, 68 deletions

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
index 1ce975c7..4e328e1f 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPControlsJB.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPControlsJB.java
@@ -21,6 +21,7 @@ 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;
@@ -50,6 +51,7 @@ public class IPControlsJB extends Activity {
     private ToggleButton mIOButton;
     private Spinner mResSpinner;
     private ListView mTestListView;
+    private TextView mResultView;
 
     private ArrayAdapter<String> mTestListAdapter;
     private ArrayList<String> mTestList = new ArrayList<String>();
@@ -59,6 +61,7 @@ public class IPControlsJB extends Activity {
     private boolean mToggleLong = false;
     private boolean mTogglePause = false;
 
+    private float mResults[];
 
     public enum Resolutions {
         RES_4K(3840, 2160, "4k (3840x2160)"),
@@ -148,7 +151,18 @@ public class IPControlsJB extends Activity {
         });
         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
@@ -212,22 +226,76 @@ public class IPControlsJB extends Activity {
         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 = IPTestListJB.TestName.values()[id[ct]].toString();
-                    s += "  " + r[ct] + "ms";
+                    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];
                 }
 
-                android.util.Log.v("rs", "result " + r);
+                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();
             }
         }
     }
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
index fb1c852f..9ad827d7 100644
--- a/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPTestListJB.java
+++ b/java/tests/ImageProcessing_jb/src/com/android/rs/image/IPTestListJB.java
@@ -32,52 +32,59 @@ public class IPTestListJB {
      * Define enum type for test names
      */
     public enum TestName {
-        LEVELS_VEC3_RELAXED ("Levels Vec3 Relaxed", RELAXED_FP),
-        LEVELS_VEC4_RELAXED ("Levels Vec4 Relaxed", RELAXED_FP),
-        LEVELS_VEC3_FULL ("Levels Vec3 Full", FULL_FP),
-        LEVELS_VEC4_FULL ("Levels Vec4 Full", FULL_FP),
-        BLUR_RADIUS_25 ("Blur radius 25", RELAXED_FP),
-        INTRINSIC_BLUR_RADIUS_25 ("Intrinsic Blur radius 25", INTRINSIC),
-        GREYSCALE ("Greyscale", RELAXED_FP),
-        GRAIN ("Grain", RELAXED_FP),
-        FISHEYE_FULL ("Fisheye Full", FULL_FP),
-        FISHEYE_RELAXED ("Fisheye Relaxed", RELAXED_FP),
-        FISHEYE_APPROXIMATE_FULL ("Fisheye Approximate Full", FULL_FP),
-        FISHEYE_APPROXIMATE_RELAXED ("Fisheye Approximate Relaxed", RELAXED_FP),
-        VIGNETTE_FULL ("Vignette Full", FULL_FP),
-        VIGNETTE_RELAXED ("Vignette Relaxed", RELAXED_FP),
-        VIGNETTE_APPROXIMATE_FULL ("Vignette Approximate Full", FULL_FP),
-        VIGNETTE_APPROXIMATE_RELAXED ("Vignette Approximate Relaxed", RELAXED_FP),
-        GROUP_TEST_EMULATED ("Group Test (emulated)", INTRINSIC),
-        GROUP_TEST_NATIVE ("Group Test (native)", INTRINSIC),
-        CONVOLVE_3X3 ("Convolve 3x3", RELAXED_FP),
-        INTRINSICS_CONVOLVE_3X3 ("Intrinsics Convolve 3x3", INTRINSIC),
-        COLOR_MATRIX ("ColorMatrix", RELAXED_FP),
-        INTRINSICS_COLOR_MATRIX ("Intrinsics ColorMatrix", INTRINSIC),
-        INTRINSICS_COLOR_MATRIX_GREY ("Intrinsics ColorMatrix Grey", INTRINSIC),
-        COPY ("Copy", RELAXED_FP),
-        CROSS_PROCESS_USING_LUT ("CrossProcess (using LUT)", INTRINSIC),
-        CONVOLVE_5X5 ("Convolve 5x5", RELAXED_FP),
-        INTRINSICS_CONVOLVE_5X5 ("Intrinsics Convolve 5x5", INTRINSIC),
-        MANDELBROT ("Mandelbrot", FULL_FP),
-        INTRINSICS_BLEND ("Intrinsics Blend", INTRINSIC),
-        INTRINSICS_BLUR_25G ("Intrinsics Blur 25 uchar", INTRINSIC),
-        VIBRANCE ("Vibrance", RELAXED_FP),
-        BW_FILTER ("BW Filter", RELAXED_FP),
-        SHADOWS ("Shadows", RELAXED_FP),
-        CONTRAST ("Contrast", RELAXED_FP),
-        EXPOSURE ("Exposure", RELAXED_FP),
-        WHITE_BALANCE ("White Balance", RELAXED_FP),
-        COLOR_CUBE ("Color Cube", RELAXED_FP),
-        COLOR_CUBE_3D_INTRINSIC ("Color Cube (3D LUT intrinsic)", INTRINSIC);
+        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
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 66b342c0..84fd7349 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
@@ -30,6 +30,8 @@ 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;
@@ -43,7 +45,6 @@ public class ImageProcessingActivityJB extends Activity
                                        implements SeekBar.OnSeekBarChangeListener,
                                                   TextureView.SurfaceTextureListener {
     private final String TAG = "Img";
-    public final String RESULT_FILE = "image_processing_result.csv";
 
     private Spinner mSpinner;
     private SeekBar mBar1;
@@ -56,7 +57,7 @@ public class ImageProcessingActivityJB extends Activity
     private TextView mText3;
     private TextView mText4;
     private TextView mText5;
-    private TextureView mDisplayView;
+    private SizedTV mDisplayView;
 
     private int mTestList[];
     private float mTestResults[];
@@ -68,6 +69,32 @@ public class ImageProcessingActivityJB extends Activity
     private int mBitmapWidth;
     private int mBitmapHeight;
 
+    static public class SizedTV extends TextureView {
+        int mWidth;
+        int mHeight;
+
+        public SizedTV(android.content.Context c) {
+            super(c);
+            mWidth = 800;
+            mHeight = 450;
+        }
+
+        public SizedTV(android.content.Context c, android.util.AttributeSet attrs) {
+            super(c, attrs);
+            mWidth = 800;
+            mHeight = 450;
+        }
+
+        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);
+        }
+    }
 
     /////////////////////////////////////////////////////////////////////////
 
@@ -88,15 +115,36 @@ public class ImageProcessingActivityJB extends Activity
 
         private boolean mBenchmarkMode;
 
-
         Processor(RenderScript rs, TextureView v, boolean benchmarkMode) {
             mRS = rs;
             mDisplayView = v;
 
-            mInPixelsAllocation = Allocation.createFromBitmapResource(
-                    mRS, getResources(), R.drawable.img1600x1067);
-            mInPixelsAllocation2 = Allocation.createFromBitmapResource(
-                    mRS, getResources(), R.drawable.img1600x1067b);
+            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,
@@ -129,7 +177,7 @@ public class ImageProcessingActivityJB extends Activity
                 mDvfsWar.go();
             }
 
-            Log.v("rs", "Warming");
+            //Log.v("rs", "Warming");
             long t = java.lang.System.currentTimeMillis() + 250;
             do {
                 mTest.runTest();
@@ -137,7 +185,7 @@ public class ImageProcessingActivityJB extends Activity
             } while (t > java.lang.System.currentTimeMillis());
             //mHandler.sendMessage(Message.obtain());
 
-            Log.v("rs", "Benchmarking");
+            //Log.v("rs", "Benchmarking");
             int ct = 0;
             t = java.lang.System.currentTimeMillis();
             do {
@@ -401,6 +449,24 @@ public class ImageProcessingActivityJB extends Activity
         t.onBar5Setup(mBar5, mText5);
     }
 
+    void hideBars() {
+        mSpinner.setVisibility(View.INVISIBLE);
+
+        mBar1.setVisibility(View.INVISIBLE);
+        mText1.setVisibility(View.INVISIBLE);
+
+        mBar2.setVisibility(View.INVISIBLE);
+        mText2.setVisibility(View.INVISIBLE);
+
+        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 cleanup() {
         synchronized(this) {
@@ -413,7 +479,7 @@ public class ImageProcessingActivityJB extends Activity
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
 
-        mDisplayView = (TextureView) findViewById(R.id.display);
+        mDisplayView = (SizedTV) findViewById(R.id.display);
 
         mSpinner = (Spinner) findViewById(R.id.spinner1);
 
@@ -466,6 +532,35 @@ public class ImageProcessingActivityJB extends Activity
 
         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;
+            }
+        }
+
+        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);
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 90757a37..107fd3a5 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
@@ -17,18 +17,18 @@
 #include "ip.rsh"
 #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 HSCALE = 256;
 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 @@ static uchar4 hsv2rgb(ushort3 hsv)
 }
 
 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 prepareShadows(float scale) {
 
 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);
 }