Remove extra float<>int conversions in ImageProcessing.

Remove or shrink test bitmaps for Fountain and ModelViewer.

Change-Id: Ieeb530375aebb6b953aa564788fc5b5ef21a362e

5 files changed, 120 insertions, 142 deletions

diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
index 24ef547..4a4d837 100644
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
+++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java
@@ -44,7 +44,6 @@ public class ImageProcessingActivity extends Activity
     private ScriptC_Threshold mScript;
     private ScriptC_Vertical_blur mScriptVBlur;
     private ScriptC_Horizontal_blur mScriptHBlur;
-    private ScriptC_Levels mScriptLevels;
     private int mRadius = 0;
     private SeekBar mRadiusSeekBar;
 
@@ -73,7 +72,8 @@ public class ImageProcessingActivity extends Activity
     @SuppressWarnings({"FieldCanBeLocal"})
     private Allocation mOutPixelsAllocation;
     @SuppressWarnings({"FieldCanBeLocal"})
-    private Allocation mScratchPixelsAllocation;
+    private Allocation mScratchPixelsAllocation1;
+    private Allocation mScratchPixelsAllocation2;
 
     private SurfaceView mSurfaceView;
     private ImageView mDisplayView;
@@ -261,29 +261,29 @@ public class ImageProcessingActivity extends Activity
             }
             else if(seekBar == mInBlackSeekBar) {
                 mInBlack = (float)progress;
-                mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
+                mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
             }
             else if(seekBar == mOutBlackSeekBar) {
                 mOutBlack = (float)progress;
-                mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
+                mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
             }
             else if(seekBar == mInWhiteSeekBar) {
                 mInWhite = (float)progress + 127.0f;
-                mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
+                mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
             }
             else if(seekBar == mOutWhiteSeekBar) {
                 mOutWhite = (float)progress + 127.0f;
-                mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
+                mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
             }
             else if(seekBar == mGammaSeekBar) {
                 mGamma = (float)progress/100.0f;
                 mGamma = Math.max(mGamma, 0.1f);
                 mGamma = 1.0f / mGamma;
-                mScriptLevels.invoke_setGamma(mGamma);
+                mScriptVBlur.invoke_setGamma(mGamma);
             }
             else if(seekBar == mSaturationSeekBar) {
                 mSaturation = (float)progress / 50.0f;
-                mScriptLevels.invoke_setSaturation(mSaturation);
+                mScriptVBlur.invoke_setSaturation(mSaturation);
             }
 
             long t = java.lang.System.currentTimeMillis();
@@ -373,28 +373,32 @@ public class ImageProcessingActivity extends Activity
 
         mInPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapIn);
         mOutPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapOut);
-        mScratchPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapScratch);
+
+        Type.Builder tb = new Type.Builder(mRS, Element.F32_4(mRS));
+        tb.add(android.renderscript.Dimension.X, mBitmapIn.getWidth());
+        tb.add(android.renderscript.Dimension.Y, mBitmapIn.getHeight());
+        mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create());
+        mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create());
 
         mScriptVBlur = new ScriptC_Vertical_blur(mRS, getResources(), R.raw.vertical_blur, false);
         mScriptHBlur = new ScriptC_Horizontal_blur(mRS, getResources(), R.raw.horizontal_blur, false);
-        mScriptLevels = new ScriptC_Levels(mRS, getResources(), R.raw.levels, false);
 
         mScript = new ScriptC_Threshold(mRS, getResources(), R.raw.threshold, false);
         mScript.set_width(mBitmapIn.getWidth());
         mScript.set_height(mBitmapIn.getHeight());
         mScript.set_radius(mRadius);
 
-        mScriptLevels.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
-        mScriptLevels.invoke_setGamma(mGamma);
-        mScriptLevels.invoke_setSaturation(mSaturation);
+        mScriptVBlur.invoke_setLevels(mInBlack, mOutBlack, mInWhite, mOutWhite);
+        mScriptVBlur.invoke_setGamma(mGamma);
+        mScriptVBlur.invoke_setSaturation(mSaturation);
 
         mScript.bind_InPixel(mInPixelsAllocation);
         mScript.bind_OutPixel(mOutPixelsAllocation);
-        mScript.bind_ScratchPixel(mScratchPixelsAllocation);
+        mScript.bind_ScratchPixel1(mScratchPixelsAllocation1);
+        mScript.bind_ScratchPixel2(mScratchPixelsAllocation2);
 
         mScript.set_vBlurScript(mScriptVBlur);
         mScript.set_hBlurScript(mScriptHBlur);
-        mScript.set_levelsScript(mScriptLevels);
     }
 
     private Bitmap loadBitmap(int resource) {
@@ -420,15 +424,15 @@ public class ImageProcessingActivity extends Activity
 
         long t = java.lang.System.currentTimeMillis();
 
-        mScript.invoke_filterBenchmark();
+        mScript.invoke_filter();
         mRS.finish();
 
         t = java.lang.System.currentTimeMillis() - t;
         android.util.Log.v("Img", "Renderscript frame time core ms " + t);
 
-        long javaTime = javaFilter();
-        mBenchmarkResult.setText("RS: " + t + " ms  Java: " + javaTime + " ms");
-        //mBenchmarkResult.setText("RS: " + t + " ms");
+        //long javaTime = javaFilter();
+        //mBenchmarkResult.setText("RS: " + t + " ms  Java: " + javaTime + " ms");
+        mBenchmarkResult.setText("RS: " + t + " ms");
 
         mRadius = oldRadius;
         mScript.set_radius(mRadius);
diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs b/libs/rs/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
index 58c9acf..cfffac8 100644
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
+++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
@@ -3,16 +3,16 @@
 #include "ip.rsh"
 
 void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) {
-    uchar4 *output = (uchar4 *)v_out;
+    float4 *output = (float4 *)v_out;
     const FilterStruct *fs = (const FilterStruct *)usrData;
-    const uchar4 *input = (const uchar4 *)rsGetElementAt(fs->ain, 0, y);
+    const float4 *input = (const float4 *)rsGetElementAt(fs->ain, 0, y);
 
     float3 blurredPixel = 0;
     const float *gPtr = fs->gaussian;
     if ((x > fs->radius) && (x < (fs->width - fs->radius))) {
-        const uchar4 *i = input + (x - fs->radius);
+        const float4 *i = input + (x - fs->radius);
         for(int r = -fs->radius; r <= fs->radius; r ++) {
-            blurredPixel += convert_float3(i->xyz) * gPtr[0];
+            blurredPixel += i->xyz * gPtr[0];
             gPtr++;
             i++;
         }
@@ -20,11 +20,11 @@ void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32
         for(int r = -fs->radius; r <= fs->radius; r ++) {
             // Stepping left and right away from the pixel
             int validW = rsClamp(x + r, (uint)0, (uint)(fs->width - 1));
-            blurredPixel += convert_float3(input[validW].xyz) * gPtr[0];
+            blurredPixel += input[validW].xyz * gPtr[0];
             gPtr++;
         }
     }
 
-    output->xyz = convert_uchar3(blurredPixel);
+    output->xyz = blurredPixel;
 }
 
diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/levels.rs b/libs/rs/java/ImageProcessing/src/com/android/rs/image/levels.rs
deleted file mode 100644
index bb8a6fc..0000000
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/levels.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#pragma version(1)
-
-#include "ip.rsh"
-
-
-static float inBlack;
-static float outBlack;
-static float inWhite;
-static float outWhite;
-static float3 gamma;
-static float saturation;
-
-static float inWMinInB;
-static float outWMinOutB;
-static float overInWMinInB;
-static rs_matrix3x3 colorMat;
-
-//#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, inBlack, outBlack, inWhite, outWhite, gamma, saturation, InPixel, OutPixel, ScratchPixel, vBlurScript, hBlurScript)
-#pragma rs export_func(setLevels, setSaturation, setGamma);
-
-void setLevels(float iBlk, float oBlk, float iWht, float oWht) {
-    inBlack = iBlk;
-    outBlack = oBlk;
-    inWhite = iWht;
-    outWhite = oWht;
-
-    inWMinInB = inWhite - inBlack;
-    outWMinOutB = outWhite - outBlack;
-    overInWMinInB = 1.f / inWMinInB;
-}
-
-void setSaturation(float sat) {
-    saturation = sat;
-
-    // Saturation
-    // Linear weights
-    //float rWeight = 0.3086f;
-    //float gWeight = 0.6094f;
-    //float bWeight = 0.0820f;
-
-    // Gamma 2.2 weights (we haven't converted our image to linear space yet for perf reasons)
-    float rWeight = 0.299f;
-    float gWeight = 0.587f;
-    float bWeight = 0.114f;
-
-    float oneMinusS = 1.0f - saturation;
-    rsMatrixSet(&colorMat, 0, 0, oneMinusS * rWeight + saturation);
-    rsMatrixSet(&colorMat, 0, 1, oneMinusS * rWeight);
-    rsMatrixSet(&colorMat, 0, 2, oneMinusS * rWeight);
-    rsMatrixSet(&colorMat, 1, 0, oneMinusS * gWeight);
-    rsMatrixSet(&colorMat, 1, 1, oneMinusS * gWeight + saturation);
-    rsMatrixSet(&colorMat, 1, 2, oneMinusS * gWeight);
-    rsMatrixSet(&colorMat, 2, 0, oneMinusS * bWeight);
-    rsMatrixSet(&colorMat, 2, 1, oneMinusS * bWeight);
-    rsMatrixSet(&colorMat, 2, 2, oneMinusS * bWeight + saturation);
-}
-
-void setGamma(float g) {
-    gamma = (float3)g;
-}
-
-
-void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) {
-    const uchar4 *input = v_in;
-    uchar4 *output = v_out;
-
-    float3 currentPixel = 0;
-
-    //currentPixel.xyz = convert_float3(input.xyz);
-    currentPixel.x = (float)(input->x);
-    currentPixel.y = (float)(input->y);
-    currentPixel.z = (float)(input->z);
-
-    float3 temp = rsMatrixMultiply(&colorMat, currentPixel);
-    temp = (clamp(temp, 0.f, 255.f) - inBlack) * overInWMinInB;
-    if (gamma.x != 1.0f)
-        temp = pow(temp, (float3)gamma);
-    currentPixel = clamp(temp * outWMinOutB + outBlack, 0.f, 255.f);
-
-    //output.xyz = convert_uchar3(currentPixel.xyz);
-    output->x = (uint8_t)currentPixel.x;
-    output->y = (uint8_t)currentPixel.y;
-    output->z = (uint8_t)currentPixel.z;
-    output->w = input->w;
-}
-
diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/threshold.rs b/libs/rs/java/ImageProcessing/src/com/android/rs/image/threshold.rs
index 8e198c7..33945a5 100644
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/threshold.rs
+++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/threshold.rs
@@ -8,14 +8,14 @@ int radius;
 
 uchar4 * InPixel;
 uchar4 * OutPixel;
-uchar4 * ScratchPixel;
+float4 * ScratchPixel1;
+float4 * ScratchPixel2;
 
-#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, vBlurScript, hBlurScript, levelsScript)
-#pragma rs export_func(filter, filterBenchmark);
+#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel1, ScratchPixel2, vBlurScript, hBlurScript)
+#pragma rs export_func(filter);
 
 rs_script vBlurScript;
 rs_script hBlurScript;
-rs_script levelsScript;
 
 const int CMD_FINISHED = 1;
 
@@ -64,7 +64,21 @@ static void computeGaussianWeights() {
 }
 
 
-static void blur() {
+static void copyInput() {
+    RS_DEBUG_MARKER;
+    rs_allocation ain = rsGetAllocation(InPixel);
+    uint32_t dimx = rsAllocationGetDimX(ain);
+    uint32_t dimy = rsAllocationGetDimY(ain);
+    for(uint32_t y = 0; y < dimy; y++) {
+        for(uint32_t x = 0; x < dimx; x++) {
+            ScratchPixel1[x + y * dimx] = convert_float4(InPixel[x + y * dimx]);
+        }
+    }
+    RS_DEBUG_MARKER;
+}
+
+void filter() {
+    copyInput();
     computeGaussianWeights();
 
     FilterStruct fs;
@@ -73,28 +87,11 @@ static void blur() {
     fs.height = height;
     fs.radius = radius;
 
-    fs.ain = rsGetAllocation(InPixel);
-    rsForEach(hBlurScript, fs.ain, rsGetAllocation(ScratchPixel), &fs);
+    fs.ain = rsGetAllocation(ScratchPixel1);
+    rsForEach(hBlurScript, fs.ain, rsGetAllocation(ScratchPixel2), &fs);
 
-    fs.ain = rsGetAllocation(ScratchPixel);
+    fs.ain = rsGetAllocation(ScratchPixel2);
     rsForEach(vBlurScript, fs.ain, rsGetAllocation(OutPixel), &fs);
-}
-
-void filter() {
-    //RS_DEBUG(radius);
-
-    if(radius > 0) {
-        blur();
-        rsForEach(levelsScript, rsGetAllocation(OutPixel), rsGetAllocation(OutPixel), 0);
-    } else {
-        rsForEach(levelsScript, rsGetAllocation(InPixel), rsGetAllocation(OutPixel), 0);
-    }
-
-    rsSendToClientBlocking(CMD_FINISHED);
-}
-
-void filterBenchmark() {
-    blur();
     rsSendToClientBlocking(CMD_FINISHED);
 }
 
diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/vertical_blur.rs b/libs/rs/java/ImageProcessing/src/com/android/rs/image/vertical_blur.rs
index 3c69289..d901d2a 100644
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/vertical_blur.rs
+++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/vertical_blur.rs
@@ -2,28 +2,91 @@
 
 #include "ip.rsh"
 
+static float inBlack;
+static float outBlack;
+static float inWhite;
+static float outWhite;
+static float3 gamma;
+static float saturation;
+
+static float inWMinInB;
+static float outWMinOutB;
+static float overInWMinInB;
+static rs_matrix3x3 colorMat;
+
+#pragma rs export_func(setLevels, setSaturation, setGamma);
+
+void setLevels(float iBlk, float oBlk, float iWht, float oWht) {
+    inBlack = iBlk;
+    outBlack = oBlk;
+    inWhite = iWht;
+    outWhite = oWht;
+
+    inWMinInB = inWhite - inBlack;
+    outWMinOutB = outWhite - outBlack;
+    overInWMinInB = 1.f / inWMinInB;
+}
+
+void setSaturation(float sat) {
+    saturation = sat;
+
+    // Saturation
+    // Linear weights
+    //float rWeight = 0.3086f;
+    //float gWeight = 0.6094f;
+    //float bWeight = 0.0820f;
+
+    // Gamma 2.2 weights (we haven't converted our image to linear space yet for perf reasons)
+    float rWeight = 0.299f;
+    float gWeight = 0.587f;
+    float bWeight = 0.114f;
+
+    float oneMinusS = 1.0f - saturation;
+    rsMatrixSet(&colorMat, 0, 0, oneMinusS * rWeight + saturation);
+    rsMatrixSet(&colorMat, 0, 1, oneMinusS * rWeight);
+    rsMatrixSet(&colorMat, 0, 2, oneMinusS * rWeight);
+    rsMatrixSet(&colorMat, 1, 0, oneMinusS * gWeight);
+    rsMatrixSet(&colorMat, 1, 1, oneMinusS * gWeight + saturation);
+    rsMatrixSet(&colorMat, 1, 2, oneMinusS * gWeight);
+    rsMatrixSet(&colorMat, 2, 0, oneMinusS * bWeight);
+    rsMatrixSet(&colorMat, 2, 1, oneMinusS * bWeight);
+    rsMatrixSet(&colorMat, 2, 2, oneMinusS * bWeight + saturation);
+}
+
+void setGamma(float g) {
+    gamma = (float3)g;
+}
+
 void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) {
     uchar4 *output = (uchar4 *)v_out;
     const FilterStruct *fs = (const FilterStruct *)usrData;
-    const uchar4 *input = (const uchar4 *)rsGetElementAt(fs->ain, x, 0);
+    const float4 *input = (const float4 *)rsGetElementAt(fs->ain, x, 0);
 
     float3 blurredPixel = 0;
     const float *gPtr = fs->gaussian;
     if ((y > fs->radius) && (y < (fs->height - fs->radius))) {
-        const uchar4 *i = input + ((y - fs->radius) * fs->width);
+        const float4 *i = input + ((y - fs->radius) * fs->width);
         for(int r = -fs->radius; r <= fs->radius; r ++) {
-            blurredPixel += convert_float3(i->xyz) * gPtr[0];
+            blurredPixel += i->xyz * gPtr[0];
             gPtr++;
             i += fs->width;
         }
     } else {
         for(int r = -fs->radius; r <= fs->radius; r ++) {
             int validH = rsClamp(y + r, (uint)0, (uint)(fs->height - 1));
-            const uchar4 *i = input + validH * fs->width;
-            blurredPixel += convert_float3(i->xyz) * gPtr[0];
+            const float4 *i = input + validH * fs->width;
+            blurredPixel += i->xyz * gPtr[0];
             gPtr++;
         }
     }
-    output->xyz = convert_uchar3(blurredPixel);
+
+    float3 temp = rsMatrixMultiply(&colorMat, blurredPixel);
+    temp = (clamp(temp, 0.f, 255.f) - inBlack) * overInWMinInB;
+    if (gamma.x != 1.0f)
+        temp = pow(temp, (float3)gamma);
+    temp = clamp(temp * outWMinOutB + outBlack, 0.f, 255.f);
+
+    output->xyz = convert_uchar3(temp);
+    //output->w = input->w;
 }