From 814326b3b945d61ea48d05e32899fb5a036cc2d3 Mon Sep 17 00:00:00 2001
From: Alex Sakhartchouk <alexst@google.com>
Date: Wed, 19 May 2010 16:28:27 -0700
Subject: [PATCH] Added benchmark mode. Added some image processing operations.

Change-Id: Ic7ba45fbf57eff6fc7d20377c148d0ba7ac862f7
---
 .../java/ImageProcessing/AndroidManifest.xml  |   3 +-
 .../java/ImageProcessing/res/layout/main.xml  | 153 +++++++-
 .../java/ImageProcessing/res/raw/threshold.rs | 329 +++++++++++++++--
 .../ImageProcessing/res/raw/threshold_bc.bc   | Bin 1528 -> 8400 bytes
 .../ImageProcessing/res/values/strings.xml    |  33 ++
 .../rs/image/ImageProcessingActivity.java     | 335 +++++++++++++++---
 .../android/rs/image/ScriptC_Threshold.java   |  56 ++-
 7 files changed, 837 insertions(+), 72 deletions(-)
 create mode 100644 libs/rs/java/ImageProcessing/res/values/strings.xml

diff --git a/libs/rs/java/ImageProcessing/AndroidManifest.xml b/libs/rs/java/ImageProcessing/AndroidManifest.xml
index b48d2082ae38d..d6a2db4a46ef8 100644
--- a/libs/rs/java/ImageProcessing/AndroidManifest.xml
+++ b/libs/rs/java/ImageProcessing/AndroidManifest.xml
@@ -6,7 +6,8 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
     <application android:label="Image Processing">
-        <activity android:name="ImageProcessingActivity">
+        <activity android:name="ImageProcessingActivity"
+                  android:screenOrientation="portrait">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
diff --git a/libs/rs/java/ImageProcessing/res/layout/main.xml b/libs/rs/java/ImageProcessing/res/layout/main.xml
index 6770c18838c90..c6ec729652aa6 100644
--- a/libs/rs/java/ImageProcessing/res/layout/main.xml
+++ b/libs/rs/java/ImageProcessing/res/layout/main.xml
@@ -25,9 +25,147 @@
         android:id="@+id/display"
         android:layout_width="320dip"
         android:layout_height="266dip" />
-    
+
+    <Button
+        android:layout_marginBottom="170dip"
+        android:layout_width="wrap_content"
+        android:layout_height="40dip"
+        android:text="@string/benchmark"
+        android:onClick="benchmark"
+        android:layout_gravity="bottom"/>
+
+    <TextView
+        android:id="@+id/benchmarkText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="100dip"
+        android:layout_marginBottom="175dip"
+        android:layout_gravity="bottom"
+        android:text="@string/saturation"/>
+
+     <SeekBar
+        android:id="@+id/inSaturation"
+        android:layout_marginBottom="140dip"
+        android:layout_marginLeft="10dip"
+        android:layout_marginRight="10dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/inSaturationText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="50dip"
+        android:layout_marginBottom="142dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/saturation"/>
+
     <SeekBar
-        android:id="@+id/threshold"
+        android:id="@+id/inGamma"
+        android:layout_marginBottom="110dip"
+        android:layout_marginLeft="10dip"
+        android:layout_marginRight="10dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/inGammaText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="50dip"
+        android:layout_marginBottom="112dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/gamma"/>
+
+    <SeekBar
+        android:id="@+id/outWhite"
+        android:layout_marginBottom="80dip"
+        android:layout_marginLeft="170dip"
+        android:layout_marginRight="10dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/outWhiteText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="220dip"
+        android:layout_marginBottom="82dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/out_white"/>
+
+    <SeekBar
+        android:id="@+id/inWhite"
+        android:layout_marginBottom="80dip"
+        android:layout_marginLeft="10dip"
+        android:layout_marginRight="170dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/inWhiteText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="50dip"
+        android:layout_marginBottom="82dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/in_white"/>
+
+    <SeekBar
+        android:id="@+id/outBlack"
+        android:layout_marginBottom="50dip"
+        android:layout_marginLeft="170dip"
+        android:layout_marginRight="10dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/outBlackText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="220dip"
+        android:layout_marginBottom="52dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/out_black"/>
+
+    <SeekBar
+        android:id="@+id/inBlack"
+        android:layout_marginBottom="50dip"
+        android:layout_marginLeft="10dip"
+        android:layout_marginRight="170dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom" />
+
+    <TextView
+        android:id="@+id/inBlackText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="50dip"
+        android:layout_marginBottom="52dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/in_black"/>
+
+    <SeekBar
+        android:id="@+id/radius"
         android:layout_marginBottom="10dip"
         android:layout_marginLeft="10dip"
         android:layout_marginRight="10dip"
@@ -35,4 +173,15 @@
         android:layout_height="wrap_content"
         android:layout_gravity="bottom" />
 
+     <TextView
+        android:id="@+id/blurText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textSize="18sp"
+        android:layout_marginLeft="50dip"
+        android:layout_marginBottom="12dip"
+        android:textColor="#000"
+        android:layout_gravity="bottom"
+        android:text="@string/blur_description"/>
+
 </merge>
\ No newline at end of file
diff --git a/libs/rs/java/ImageProcessing/res/raw/threshold.rs b/libs/rs/java/ImageProcessing/res/raw/threshold.rs
index 8dc614e22a254..0317088360f9c 100644
--- a/libs/rs/java/ImageProcessing/res/raw/threshold.rs
+++ b/libs/rs/java/ImageProcessing/res/raw/threshold.rs
@@ -4,46 +4,331 @@
 #include "../../../../scriptc/rs_math.rsh"
 #include "../../../../scriptc/rs_graphics.rsh"
 
+#define MAX_RADIUS 25
+
 int height;
 int width;
-float threshold;
+int radius;
 
 typedef struct c4u_s {
-    char r, g, b, a;
+    uint8_t r, g, b, a;
 } c4u_t;
 
-//rs_color4u * InPixel;
-//rs_color4u * OutPixel;
 c4u_t * InPixel;
 c4u_t * OutPixel;
+c4u_t * ScratchPixel;
 
-#pragma rs export_var(height, width, threshold, InPixel, OutPixel)
+float inBlack;
+float outBlack;
+float inWhite;
+float outWhite;
+float gamma;
+
+float saturation;
+
+float inWMinInB;
+float outWMinOutB;
+
+#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, inBlack, outBlack, inWhite, outWhite, gamma, saturation)
+#pragma rs export_func(filter, processNoBlur, computeColorMatrix, computeGaussianWeights);
+
+// Store our coefficients here
+float gaussian[MAX_RADIUS * 2 + 1];
+float colorMat[4][4];
+
+void computeColorMatrix() {
+    // 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;
+
+    matrixLoadIdentity(colorMat);
+
+    colorMat[0][0] = oneMinusS * rWeight + saturation;
+    colorMat[0][1] = oneMinusS * rWeight;
+    colorMat[0][2] = oneMinusS * rWeight;
+    colorMat[1][0] = oneMinusS * gWeight;
+    colorMat[1][1] = oneMinusS * gWeight + saturation;
+    colorMat[1][2] = oneMinusS * gWeight;
+    colorMat[2][0] = oneMinusS * bWeight;
+    colorMat[2][1] = oneMinusS * bWeight;
+    colorMat[2][2] = oneMinusS * bWeight + saturation;
+
+    inWMinInB = inWhite - inBlack;
+    outWMinOutB = outWhite - outBlack;
+}
+
+void computeGaussianWeights() {
+    // Compute gaussian weights for the blur
+    // e is the euler's number
+    float e = 2.718281828459045f;
+    float pi = 3.1415926535897932f;
+    // g(x) = ( 1 / sqrt( 2 * pi ) * sigma) * e ^ ( -x^2 / 2 * sigma^2 )
+    // x is of the form [-radius .. 0 .. radius]
+    // and sigma varies with radius.
+    // Based on some experimental radius values and sigma's
+    // we approximately fit sigma = f(radius) as
+    // sigma = radius * 0.4  + 0.6
+    // The larger the radius gets, the more our gaussian blur
+    // will resemble a box blur since with large sigma
+    // the gaussian curve begins to lose its shape
+    float sigma = 0.4f * (float)radius + 0.6f;
+
+    // Now compute the coefficints
+    // We will store some redundant values to save some math during
+    // the blur calculations
+    // precompute some values
+    float coeff1 = 1.0f / (sqrt( 2.0f * pi ) * sigma);
+    float coeff2 = - 1.0f / (2.0f * sigma * sigma);
+
+    float normalizeFactor = 0.0f;
+    float floatR = 0.0f;
+    int r;
+    for(r = -radius; r <= radius; r ++) {
+        floatR = (float)r;
+        gaussian[r + radius] = coeff1 * pow(e, floatR * floatR * coeff2);
+        normalizeFactor += gaussian[r + radius];
+    }
+
+    //Now we need to normalize the weights because all our coefficients need to add up to one
+    normalizeFactor = 1.0f / normalizeFactor;
+    for(r = -radius; r <= radius; r ++) {
+        floatR = (float)r;
+        gaussian[r + radius] *= normalizeFactor;
+    }
+}
+
+// This needs to be inline
+void levelsSaturation(float4 *currentPixel) {
+    // Color matrix multiply
+    float tempX = colorMat[0][0] * currentPixel->x + colorMat[1][0] * currentPixel->y + colorMat[2][0] * currentPixel->z;
+    float tempY = colorMat[0][1] * currentPixel->x + colorMat[1][1] * currentPixel->y + colorMat[2][1] * currentPixel->z;
+    float tempZ = colorMat[0][2] * currentPixel->x + colorMat[1][2] * currentPixel->y + colorMat[2][2] * currentPixel->z;
+
+    currentPixel->x = tempX;
+    currentPixel->y = tempY;
+    currentPixel->z = tempZ;
+
+    // Clamp to 0..255
+    // Inline the code here to avoid funciton calls
+    currentPixel->x = currentPixel->x > 255.0f ? 255.0f : currentPixel->x;
+    currentPixel->y = currentPixel->y > 255.0f ? 255.0f : currentPixel->y;
+    currentPixel->z = currentPixel->z > 255.0f ? 255.0f : currentPixel->z;
+
+    currentPixel->x = currentPixel->x <= 0.0f ? 0.1f : currentPixel->x;
+    currentPixel->y = currentPixel->y <= 0.0f ? 0.1f : currentPixel->y;
+    currentPixel->z = currentPixel->z <= 0.0f ? 0.1f : currentPixel->z;
+
+    currentPixel->x = pow( (currentPixel->x - inBlack) / (inWMinInB), gamma) * (outWMinOutB) + outBlack;
+    currentPixel->y = pow( (currentPixel->y - inBlack) / (inWMinInB), gamma) * (outWMinOutB) + outBlack;
+    currentPixel->z = pow( (currentPixel->z - inBlack) / (inWMinInB), gamma) * (outWMinOutB) + outBlack;
+
+    currentPixel->x = currentPixel->x > 255.0f ? 255.0f : currentPixel->x;
+    currentPixel->y = currentPixel->y > 255.0f ? 255.0f : currentPixel->y;
+    currentPixel->z = currentPixel->z > 255.0f ? 255.0f : currentPixel->z;
+
+    currentPixel->x = currentPixel->x <= 0.0f ? 0.1f : currentPixel->x;
+    currentPixel->y = currentPixel->y <= 0.0f ? 0.1f : currentPixel->y;
+    currentPixel->z = currentPixel->z <= 0.0f ? 0.1f : currentPixel->z;
+}
+
+void processNoBlur() {
+    int w, h, r;
+    int count = 0;
+
+    float inWMinInB = inWhite - inBlack;
+    float outWMinOutB = outWhite - outBlack;
+    float4 currentPixel = 0;
+
+    for(h = 0; h < height; h ++) {
+        for(w = 0; w < width; w ++) {
+            c4u_t *input = InPixel + h*width + w;
+
+            currentPixel.x = (float)(input->r);
+            currentPixel.y = (float)(input->g);
+            currentPixel.z = (float)(input->b);
+
+            levelsSaturation(&currentPixel);
+
+            c4u_t *output = OutPixel + h*width + w;
+            output->r = (uint8_t)currentPixel.x;
+            output->g = (uint8_t)currentPixel.y;
+            output->b = (uint8_t)currentPixel.z;
+            output->a = input->a;
+        }
+    }
+    sendToClient(&count, 1, 4, 0);
+}
+
+void horizontalBlur() {
+    float4 blurredPixel = 0;
+    float4 currentPixel = 0;
+    // Horizontal blur
+    int w, h, r;
+    for(h = 0; h < height; h ++) {
+        for(w = 0; w < width; w ++) {
+
+            blurredPixel = 0;
+
+            for(r = -radius; r <= radius; r ++) {
+                // Stepping left and right away from the pixel
+                int validW = w + r;
+                // Clamp to zero and width max() isn't exposed for ints yet
+                if(validW < 0) {
+                    validW = 0;
+                }
+                if(validW > width - 1) {
+                    validW = width - 1;
+                }
+
+                c4u_t *input = InPixel + h*width + validW;
+
+                float weight = gaussian[r + radius];
+                currentPixel.x = (float)(input->r);
+                currentPixel.y = (float)(input->g);
+                currentPixel.z = (float)(input->b);
+                //currentPixel.w = (float)(input->a);
+
+                blurredPixel += currentPixel*weight;
+            }
+
+            c4u_t *output = ScratchPixel + h*width + w;
+            output->r = (uint8_t)blurredPixel.x;
+            output->g = (uint8_t)blurredPixel.y;
+            output->b = (uint8_t)blurredPixel.z;
+            //output->a = (uint8_t)blurredPixel.w;
+        }
+    }
+}
+
+void horizontalBlurLevels() {
+    float4 blurredPixel = 0;
+    float4 currentPixel = 0;
+    // Horizontal blur
+    int w, h, r;
+    for(h = 0; h < height; h ++) {
+        for(w = 0; w < width; w ++) {
+
+            blurredPixel = 0;
+
+            for(r = -radius; r <= radius; r ++) {
+                // Stepping left and right away from the pixel
+                int validW = w + r;
+                // Clamp to zero and width max() isn't exposed for ints yet
+                if(validW < 0) {
+                    validW = 0;
+                }
+                if(validW > width - 1) {
+                    validW = width - 1;
+                }
+
+                c4u_t *input = InPixel + h*width + validW;
+
+                float weight = gaussian[r + radius];
+                currentPixel.x = (float)(input->r);
+                currentPixel.y = (float)(input->g);
+                currentPixel.z = (float)(input->b);
+                //currentPixel.w = (float)(input->a);
+
+                blurredPixel += currentPixel*weight;
+            }
+
+            levelsSaturation(&blurredPixel);
+
+            c4u_t *output = ScratchPixel + h*width + w;
+            output->r = (uint8_t)blurredPixel.x;
+            output->g = (uint8_t)blurredPixel.y;
+            output->b = (uint8_t)blurredPixel.z;
+            //output->a = (uint8_t)blurredPixel.w;
+        }
+    }
+}
+
+void verticalBlur() {
+    float4 blurredPixel = 0;
+    float4 currentPixel = 0;
+    // Vertical blur
+    int w, h, r;
+    for(h = 0; h < height; h ++) {
+        for(w = 0; w < width; w ++) {
+
+            blurredPixel = 0;
+            for(r = -radius; r <= radius; r ++) {
+                int validH = h + r;
+                // Clamp to zero and width
+                if(validH < 0) {
+                    validH = 0;
+                }
+                if(validH > height - 1) {
+                    validH = height - 1;
+                }
+
+                c4u_t *input = ScratchPixel + validH*width + w;
+
+                float weight = gaussian[r + radius];
+
+                currentPixel.x = (float)(input->r);
+                currentPixel.y = (float)(input->g);
+                currentPixel.z = (float)(input->b);
+                //currentPixel.w = (float)(input->a);
+
+                blurredPixel += currentPixel*weight;
+            }
+
+            c4u_t *output = OutPixel + h*width + w;
+
+            output->r = (uint8_t)blurredPixel.x;
+            output->g = (uint8_t)blurredPixel.y;
+            output->b = (uint8_t)blurredPixel.z;
+            //output->a = (uint8_t)blurredPixel.w;
+        }
+    }
+}
 
 void filter() {
     debugP(0, (void *)height);
     debugP(0, (void *)width);
-    debugP(0, (void *)((int)threshold));
-    debugP(0, (void *)InPixel);
-    debugP(0, (void *)OutPixel);
+    debugP(0, (void *)radius);
 
-    rs_color4u *in = (rs_color4u *)InPixel;
-    rs_color4u *out = (rs_color4u *)OutPixel;
-    //const rs_color4u mask = {0,0,0,0xff};
+    debugPf(10, inBlack);
+    debugPf(11, outBlack);
+    debugPf(12, inWhite);
+    debugPf(13, outWhite);
+    debugPf(14, gamma);
+    debugPf(15, saturation);
 
-    int count = width * height;
-    int tf = threshold * 255 * 255;
-    int masks[2] = {0xffffffff, 0xff000000};
+    computeColorMatrix();
 
-    while (count--) {
-        int luminance = 54 * in->x +
-                        182 * in->y +
-                        18 * in->z;
-        int idx = ((uint32_t)(luminance - tf)) >> 31;
-        *((int *)out) = *((int *)in) & masks[idx];
-        in++;
-        out++;
+    if(radius == 0) {
+        processNoBlur();
+        return;
     }
 
+    computeGaussianWeights();
+
+    horizontalBlurLevels();
+    verticalBlur();
+
+    int count = 0;
+    sendToClient(&count, 1, 4, 0);
+}
+
+void filterBenchmark() {
+
+    computeGaussianWeights();
+
+    horizontalBlur();
+    verticalBlur();
+
+    int count = 0;
     sendToClient(&count, 1, 4, 0);
 }
 
diff --git a/libs/rs/java/ImageProcessing/res/raw/threshold_bc.bc b/libs/rs/java/ImageProcessing/res/raw/threshold_bc.bc
index 55d514cd0a1ca33cc7e85d8c9c0da961bbdd3108..58a93e6cc61542b26abccd1315bbafbf4477b70a 100644
GIT binary patch
literal 8400
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
DJO=Yz

delta 1244
zcmXYv4NOy46vyxTDDS=UEU&b}W3>1RO;faPZ9y%yn$o`3q7_?lOcR$-0k<p>f#BEt
zXkS|yLsUMsZkp7EEL-LhoPsskvSL|91;s%CGj;876<uZwE^}Kpx4vXIxxahvKlj}K
zxhHp`{Etkb#TtF6AOScCbqR}#q&C>nooVT(^il&(R|xg2(jn|r6pd{5k$H+{B{u5l
zaw#`T008<z2f@_)gFt0-2ndxej`tMK!HQxDIwON<5}i<(yXVQM4AKkC!KYfdX-tgP
zz3WyUgQL{rvn8<0zpa&Ei+!N$=P7T{!4$D95D6Z;8iz98X>L?ukG&~Hg-!^lv=>>?
z>&DY7sByr@EqnmBF=-I#sV@jod17a02ccRQN3C!XSmEM)KB~?R+B$%XEzbqu01W`2
zCTU~vpdiE8Yc-xlj1w_`RHULHG49Q5Kj^@k!&pnmjM^JDj(JG_=)5ci$scm^QBOI8
zr89|M!MddpMAMI~?L}5=)NxMqG?|<7z+x@;6*zG8{V=xGfgMs~d+B5cXBvyW(Tl8&
z##WCaYyS4H2?k6T)V}lPQ-u9F>Y|q8k35i0G*5{Z1{j|=K-jecUcK${i?={hHWO|N
z)u3+y!CgNiv(xojQHv|<TW!`deBCD(2urwQf81P<O6J~#mL!t$M_j=Xu3!NwxaqNV
zZe-xs=W}GgyF?4xtS8S!&jy&bfcQEc4VZ$lvddP(1$-s&FaUhScLZfM6z~F&k=~%|
z!?W#ghw=9QLqcwhhH(EYIj@&2ij`16Br#TtLnB>vQr~3o#G9z9NtsV14CWa^{sr#*
z$zggex<7VWS-Y64kP$Qm#q+N*74fBTk0DzZhA2o4P@g`ar?P$LIM_ejwrmloi6qHv
zZK&Q$!z<LK1O3y{?pnlr3B6_(bfTXzq@sh%zn>qGTNq?j#6WLo1aT_Glo^4054b^J
zlbQBmj4-P(&l*CW{07)xhn0QUE@~Rv3;YYnTHjxYaJMLWVwIFocdC8Dqwa}eyo?cm
zaOT!xHA8nqoDgWuU$20?f#v|VGcO}4eU`m?S{y>Vg`4_n3>0vuU!T+CfZcf`J#($K
zcxBbSZ;Hk6fJSxcfAK(rIncu9Y;leSW>)h2afm<mATmrl<|eQ1vfz{rw34U)A+s0H
z-ck^3J$3RNNe<HA`%A3?_K0=+Bqa5+CALtXRPti#@)@3k=XqZFQc4a^MK1FEQ$Uv|
zR^9Qi$OL(6Ga2-~{M7HPOc*v)ew?AxZQ3Op88HnVrX(-!=UCE3{DA9pCmSkS6Qzr9
z=My?z*6!S+3D<a?J!ZyJJD717beB+1bDH211F};d+>t2lyPLM0y)w>o=w8}#_UZ#Z
z{(6x1Pi`4(Sc7QE>Y#J1>g6lRy)IoDH>WvOrJZV?OjUtc<1ei`=UA;tU|qhi!T8;X
z>E&VM!#zx9QZin%B3(q^ainMal7jd8L$dWdD^Jf{Z<z^I|9cw(povNULB7eZt)p6b
zbyPa47kAwO-Gyg3H*<?+_tucCIq!3b#yI+V9rD3!|ENu4_l2i=3v(~haFKX?!g$|L
Sjn~09TG(KV;a2)Ce*6c;{HcBb

diff --git a/libs/rs/java/ImageProcessing/res/values/strings.xml b/libs/rs/java/ImageProcessing/res/values/strings.xml
new file mode 100644
index 0000000000000..cc5cc4de9782b
--- /dev/null
+++ b/libs/rs/java/ImageProcessing/res/values/strings.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+* Copyright (C) 2008 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.
+*/
+-->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- General -->
+    <skip />
+    <!--slider label -->
+    <string name="blur_description">Blur Radius</string>
+    <string name="in_white">In White</string>
+    <string name="out_white">Out White</string>
+    <string name="in_black">In Black</string>
+    <string name="out_black">Out Black</string>
+    <string name="gamma">Gamma</string>
+    <string name="saturation">Saturation</string>
+    <string name="benchmark">Benchmark</string>
+
+</resources>
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 aec5e23ca7a49..5e36a78d53fee 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
@@ -31,13 +31,35 @@ import android.view.SurfaceView;
 import android.view.SurfaceHolder;
 import android.widget.ImageView;
 import android.widget.SeekBar;
+import android.widget.TextView;
+import android.view.View;
 import java.lang.Math;
 
-public class ImageProcessingActivity extends Activity implements SurfaceHolder.Callback {
+public class ImageProcessingActivity extends Activity
+                                       implements SurfaceHolder.Callback,
+                                       SeekBar.OnSeekBarChangeListener {
     private Bitmap mBitmapIn;
     private Bitmap mBitmapOut;
+    private Bitmap mBitmapScratch;
     private ScriptC_Threshold mScript;
-    private float mThreshold = 0.5f;
+    private int mRadius = 0;
+    private SeekBar mRadiusSeekBar;
+
+    private float mInBlack = 0.0f;
+    private SeekBar mInBlackSeekBar;
+    private float mOutBlack = 0.0f;
+    private SeekBar mOutBlackSeekBar;
+    private float mInWhite = 255.0f;
+    private SeekBar mInWhiteSeekBar;
+    private float mOutWhite = 255.0f;
+    private SeekBar mOutWhiteSeekBar;
+    private float mGamma = 1.0f;
+    private SeekBar mGammaSeekBar;
+
+    private float mSaturation = 1.0f;
+    private SeekBar mSaturationSeekBar;
+
+    private TextView mBenchmarkResult;
 
     @SuppressWarnings({"FieldCanBeLocal"})
     private RenderScript mRS;
@@ -47,6 +69,8 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
     private Allocation mInPixelsAllocation;
     @SuppressWarnings({"FieldCanBeLocal"})
     private Allocation mOutPixelsAllocation;
+    @SuppressWarnings({"FieldCanBeLocal"})
+    private Allocation mScratchPixelsAllocation;
 
     private SurfaceView mSurfaceView;
     private ImageView mDisplayView;
@@ -66,34 +90,217 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
     }
 
     int in[];
+    int interm[];
     int out[];
-    private void javaFilter() {
-        final int w = mBitmapIn.getWidth();
-        final int h = mBitmapIn.getHeight();
-        final int count = w * h;
+    int MAX_RADIUS = 25;
+    // Store our coefficients here
+    float gaussian[];
+
+    private long javaFilter() {
+        final int width = mBitmapIn.getWidth();
+        final int height = mBitmapIn.getHeight();
+        final int count = width * height;
 
         if (in == null) {
             in = new int[count];
+            interm = new int[count];
             out = new int[count];
-            mBitmapIn.getPixels(in, 0, w, 0, 0, w, h);
+            gaussian = new float[MAX_RADIUS * 2 + 1];
+            mBitmapIn.getPixels(in, 0, width, 0, 0, width, height);
         }
 
-        int threshold = (int)(mThreshold * 255.f) * 255;
-        //long t = java.lang.System.currentTimeMillis();
+        long t = java.lang.System.currentTimeMillis();
 
-        for (int i = 0; i < count; i++) {
-            final int luminance = 54 * ((in[i] >> 0) & 0xff) +
-                                  182* ((in[i] >> 8) & 0xff) +
-                                  18 * ((in[i] >> 16) & 0xff);
-            if (luminance > threshold) {
-                out[i] = in[i];
-            } else {
-                out[i] = in[i] & 0xff000000;
+        int w, h, r;
+
+        float fRadius = (float)mRadius;
+        int radius = (int)mRadius;
+
+        // Compute gaussian weights for the blur
+        // e is the euler's number
+        float e = 2.718281828459045f;
+        float pi = 3.1415926535897932f;
+        // g(x) = ( 1 / sqrt( 2 * pi ) * sigma) * e ^ ( -x^2 / 2 * sigma^2 )
+        // x is of the form [-radius .. 0 .. radius]
+        // and sigma varies with radius.
+        // Based on some experimental radius values and sigma's
+        // we approximately fit sigma = f(radius) as
+        // sigma = radius * 0.4  + 0.6
+        // The larger the radius gets, the more our gaussian blur
+        // will resemble a box blur since with large sigma
+        // the gaussian curve begins to lose its shape
+        float sigma = 0.4f * fRadius + 0.6f;
+        // Now compute the coefficints
+        // We will store some redundant values to save some math during
+        // the blur calculations
+        // precompute some values
+        float coeff1 = 1.0f / (float)(Math.sqrt( 2.0f * pi ) * sigma);
+        float coeff2 = - 1.0f / (2.0f * sigma * sigma);
+        float normalizeFactor = 0.0f;
+        float floatR = 0.0f;
+        for(r = -radius; r <= radius; r ++) {
+            floatR = (float)r;
+            gaussian[r + radius] = coeff1 * (float)Math.pow(e, floatR * floatR * coeff2);
+            normalizeFactor += gaussian[r + radius];
+        }
+
+        //Now we need to normalize the weights because all our coefficients need to add up to one
+        normalizeFactor = 1.0f / normalizeFactor;
+        for(r = -radius; r <= radius; r ++) {
+            floatR = (float)r;
+            gaussian[r + radius] *= normalizeFactor;
+        }
+
+        float blurredPixelR = 0.0f;
+        float blurredPixelG = 0.0f;
+        float blurredPixelB = 0.0f;
+        float blurredPixelA = 0.0f;
+
+        for(h = 0; h < height; h ++) {
+            for(w = 0; w < width; w ++) {
+
+                blurredPixelR = 0.0f;
+                blurredPixelG = 0.0f;
+                blurredPixelB = 0.0f;
+                blurredPixelA = 0.0f;
+
+                for(r = -radius; r <= radius; r ++) {
+                    // Stepping left and right away from the pixel
+                    int validW = w + r;
+                    // Clamp to zero and width max() isn't exposed for ints yet
+                    if(validW < 0) {
+                        validW = 0;
+                    }
+                    if(validW > width - 1) {
+                        validW = width - 1;
+                    }
+
+                    int input = in[h*width + validW];
+
+                    int R = ((input >> 24) & 0xff);
+                    int G = ((input >> 16) & 0xff);
+                    int B = ((input >> 8) & 0xff);
+                    int A = (input & 0xff);
+
+                    float weight = gaussian[r + radius];
+
+                    blurredPixelR += (float)(R)*weight;
+                    blurredPixelG += (float)(G)*weight;
+                    blurredPixelB += (float)(B)*weight;
+                    blurredPixelA += (float)(A)*weight;
+                }
+
+                int R = (int)blurredPixelR;
+                int G = (int)blurredPixelG;
+                int B = (int)blurredPixelB;
+                int A = (int)blurredPixelA;
+
+                interm[h*width + w] = (R << 24) | (G << 16) | (B << 8) | (A);
             }
         }
-        //t = java.lang.System.currentTimeMillis() - t;
-        //android.util.Log.v("Img", "frame time ms " + t);
-        mBitmapOut.setPixels(out, 0, w, 0, 0, w, h);
+
+        for(h = 0; h < height; h ++) {
+            for(w = 0; w < width; w ++) {
+
+                blurredPixelR = 0.0f;
+                blurredPixelG = 0.0f;
+                blurredPixelB = 0.0f;
+                blurredPixelA = 0.0f;
+                for(r = -radius; r <= radius; r ++) {
+                    int validH = h + r;
+                    // Clamp to zero and width
+                    if(validH < 0) {
+                        validH = 0;
+                    }
+                    if(validH > height - 1) {
+                        validH = height - 1;
+                    }
+
+                    int input = interm[validH*width + w];
+
+                    int R = ((input >> 24) & 0xff);
+                    int G = ((input >> 16) & 0xff);
+                    int B = ((input >> 8) & 0xff);
+                    int A = (input & 0xff);
+
+                    float weight = gaussian[r + radius];
+
+                    blurredPixelR += (float)(R)*weight;
+                    blurredPixelG += (float)(G)*weight;
+                    blurredPixelB += (float)(B)*weight;
+                    blurredPixelA += (float)(A)*weight;
+                }
+
+                int R = (int)blurredPixelR;
+                int G = (int)blurredPixelG;
+                int B = (int)blurredPixelB;
+                int A = (int)blurredPixelA;
+
+                out[h*width + w] = (R << 24) | (G << 16) | (B << 8) | (A);
+            }
+        }
+
+        t = java.lang.System.currentTimeMillis() - t;
+        android.util.Log.v("Img", "Java frame time ms " + t);
+        mBitmapOut.setPixels(out, 0, width, 0, 0, width, height);
+        return t;
+    }
+
+    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+        if (fromUser) {
+
+            if(seekBar == mRadiusSeekBar) {
+                float fRadius = progress / 100.0f;
+                fRadius *= (float)(MAX_RADIUS);
+                mRadius = (int)fRadius;
+
+                mScript.set_radius(mRadius);
+            }
+            else if(seekBar == mInBlackSeekBar) {
+                mInBlack = (float)progress;
+                mScript.set_inBlack(mInBlack);
+            }
+            else if(seekBar == mOutBlackSeekBar) {
+                mOutBlack = (float)progress;
+                mScript.set_outBlack(mOutBlack);
+            }
+            else if(seekBar == mInWhiteSeekBar) {
+                mInWhite = (float)progress + 127.0f;
+                mScript.set_inWhite(mInWhite);
+            }
+            else if(seekBar == mOutWhiteSeekBar) {
+                mOutWhite = (float)progress + 127.0f;
+                mScript.set_outWhite(mOutWhite);
+            }
+            else if(seekBar == mGammaSeekBar) {
+                mGamma = (float)progress/100.0f;
+                mGamma = Math.max(mGamma, 0.1f);
+                mGamma = 1.0f / mGamma;
+                mScript.set_gamma(mGamma);
+            }
+            else if(seekBar == mSaturationSeekBar) {
+                mSaturation = (float)progress / 50.0f;
+                mScript.set_saturation(mSaturation);
+            }
+
+            long t = java.lang.System.currentTimeMillis();
+            if (true) {
+                mScript.invokable_Filter();
+            } else {
+                javaFilter();
+            }
+
+            t = java.lang.System.currentTimeMillis() - t;
+            android.util.Log.v("Img", "Renderscript frame time core ms " + t);
+
+            mDisplayView.invalidate();
+        }
+    }
+
+    public void onStartTrackingTouch(SeekBar seekBar) {
+    }
+
+    public void onStopTrackingTouch(SeekBar seekBar) {
     }
 
     @Override
@@ -103,6 +310,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
 
         mBitmapIn = loadBitmap(R.drawable.data);
         mBitmapOut = loadBitmap(R.drawable.data);
+        mBitmapScratch = loadBitmap(R.drawable.data);
 
         mSurfaceView = (SurfaceView) findViewById(R.id.surface);
         mSurfaceView.getHolder().addCallback(this);
@@ -110,31 +318,38 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
         mDisplayView = (ImageView) findViewById(R.id.display);
         mDisplayView.setImageBitmap(mBitmapOut);
 
-        ((SeekBar) findViewById(R.id.threshold)).setOnSeekBarChangeListener(
-                new SeekBar.OnSeekBarChangeListener() {
-            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
-                if (fromUser) {
-                    mThreshold = progress / 100.0f;
-                    mScript.set_threshold(mThreshold);
+        mRadiusSeekBar = (SeekBar) findViewById(R.id.radius);
+        mRadiusSeekBar.setOnSeekBarChangeListener(this);
 
-                    long t = java.lang.System.currentTimeMillis();
-                    if (true) {
-                        mScript.invokable_Filter();
-                    } else {
-                        javaFilter();
-                        mDisplayView.invalidate();
-                    }
-                    t = java.lang.System.currentTimeMillis() - t;
-                    android.util.Log.v("Img", "frame time core ms " + t);
-                }
-            }
+        mInBlackSeekBar = (SeekBar)findViewById(R.id.inBlack);
+        mInBlackSeekBar.setOnSeekBarChangeListener(this);
+        mInBlackSeekBar.setMax(128);
+        mInBlackSeekBar.setProgress(0);
+        mOutBlackSeekBar = (SeekBar)findViewById(R.id.outBlack);
+        mOutBlackSeekBar.setOnSeekBarChangeListener(this);
+        mOutBlackSeekBar.setMax(128);
+        mOutBlackSeekBar.setProgress(0);
 
-            public void onStartTrackingTouch(SeekBar seekBar) {
-            }
+        mInWhiteSeekBar = (SeekBar)findViewById(R.id.inWhite);
+        mInWhiteSeekBar.setOnSeekBarChangeListener(this);
+        mInWhiteSeekBar.setMax(128);
+        mInWhiteSeekBar.setProgress(128);
+        mOutWhiteSeekBar = (SeekBar)findViewById(R.id.outWhite);
+        mOutWhiteSeekBar.setOnSeekBarChangeListener(this);
+        mOutWhiteSeekBar.setMax(128);
+        mOutWhiteSeekBar.setProgress(128);
 
-            public void onStopTrackingTouch(SeekBar seekBar) {
-            }
-        });
+        mGammaSeekBar = (SeekBar)findViewById(R.id.inGamma);
+        mGammaSeekBar.setOnSeekBarChangeListener(this);
+        mGammaSeekBar.setMax(150);
+        mGammaSeekBar.setProgress(100);
+
+        mSaturationSeekBar = (SeekBar)findViewById(R.id.inSaturation);
+        mSaturationSeekBar.setOnSeekBarChangeListener(this);
+        mSaturationSeekBar.setProgress(50);
+
+        mBenchmarkResult = (TextView) findViewById(R.id.benchmarkText);
+        mBenchmarkResult.setText("Benchmark no yet run");
     }
 
     public void surfaceCreated(SurfaceHolder holder) {
@@ -154,13 +369,23 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
 
         mInPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapIn);
         mOutPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapOut);
+        mScratchPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapScratch);
 
         mScript = new ScriptC_Threshold(mRS, getResources(), false);
         mScript.set_width(mBitmapIn.getWidth());
         mScript.set_height(mBitmapIn.getHeight());
-        mScript.set_threshold(mThreshold);
+        mScript.set_radius(mRadius);
+
+        mScript.set_inBlack(mInBlack);
+        mScript.set_outBlack(mOutBlack);
+        mScript.set_inWhite(mInWhite);
+        mScript.set_outWhite(mOutWhite);
+        mScript.set_gamma(mGamma);
+        mScript.set_saturation(mSaturation);
+
         mScript.bind_InPixel(mInPixelsAllocation);
         mScript.bind_OutPixel(mOutPixelsAllocation);
+        mScript.bind_ScratchPixel(mScratchPixelsAllocation);
     }
 
     private Bitmap loadBitmap(int resource) {
@@ -176,4 +401,28 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C
         source.recycle();
         return b;
     }
+
+    // button hook
+    public void benchmark(View v) {
+        android.util.Log.v("Img", "Benchmarking");
+        int oldRadius = mRadius;
+        mRadius = MAX_RADIUS;
+        mScript.set_radius(mRadius);
+
+        long t = java.lang.System.currentTimeMillis();
+
+        mScript.invokable_FilterBenchmark();
+
+        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");
+
+        mRadius = oldRadius;
+        mScript.set_radius(mRadius);
+
+        mScript.invokable_Filter();
+    }
 }
diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java
index dbaa18c2e2356..dfed9e55a038d 100644
--- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java
+++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java
@@ -10,12 +10,23 @@ public class ScriptC_Threshold
 {
     private final static int mFieldIndex_height = 0;
     private final static int mFieldIndex_width = 1;
-    private final static int mFieldIndex_threshold = 2;
+    private final static int mFieldIndex_radius = 2;
     private final static int mFieldIndex_InPixel = 3;
     private final static int mFieldIndex_OutPixel = 4;
+    private final static int mFieldIndex_ScratchPixel = 5;
+
+    private final static int mFieldIndex_inBlack = 6;
+    private final static int mFieldIndex_outBlack = 7;
+    private final static int mFieldIndex_inWhite = 8;
+    private final static int mFieldIndex_outWhite = 9;
+    private final static int mFieldIndex_gamma = 10;
+
+    private final static int mFieldIndex_saturation = 11;
+    private final static int mFieldIndex_hue = 12;
 
     private Allocation mField_InPixel;
     private Allocation mField_OutPixel;
+    private Allocation mField_ScratchPixel;
 
     public ScriptC_Threshold(RenderScript rs, Resources resources, boolean isRoot) {
         super(rs, resources, R.raw.threshold_bc, isRoot);
@@ -43,6 +54,15 @@ public class ScriptC_Threshold
         bindAllocation(f, mFieldIndex_OutPixel);
         mField_OutPixel = f;
     }
+    public void bind_ScratchPixel(Allocation f) {
+        if (f != null) {
+            //if (f.getType().getElement() != Element.ATTRIB_COLOR_U8_4(mRS)) {
+                //throw new IllegalArgumentException("Element type mismatch.");
+            //}
+        }
+        bindAllocation(f, mFieldIndex_ScratchPixel);
+        mField_ScratchPixel = f;
+    }
     public Allocation get_OutPixel() {
         return mField_OutPixel;
     }
@@ -55,13 +75,41 @@ public class ScriptC_Threshold
         setVar(mFieldIndex_width, v);
     }
 
-    public void set_threshold(float v) {
-        setVar(mFieldIndex_threshold, v);
+    public void set_radius(int v) {
+        setVar(mFieldIndex_radius, v);
     }
 
-    private final static int mInvokableIndex_Filter = 0;
+    public void set_inBlack(float v) {
+        setVar(mFieldIndex_inBlack, v);
+    }
+    public void set_outBlack(float v) {
+        setVar(mFieldIndex_outBlack, v);
+    }
+    public void set_inWhite(float v) {
+        setVar(mFieldIndex_inWhite, v);
+    }
+    public void set_outWhite(float v) {
+        setVar(mFieldIndex_outWhite, v);
+    }
+    public void set_gamma(float v) {
+        setVar(mFieldIndex_gamma, v);
+    }
+
+    public void set_saturation(float v) {
+        setVar(mFieldIndex_saturation, v);
+    }
+    public void set_hue(float v) {
+        setVar(mFieldIndex_hue, v);
+    }
+
+    private final static int mInvokableIndex_Filter = 2;
     public void invokable_Filter() {
         invokeData(mInvokableIndex_Filter);
     }
+
+    private final static int mInvokableIndex_FilterBenchmark = 3;
+    public void invokable_FilterBenchmark() {
+        invokeData(mInvokableIndex_FilterBenchmark);
+    }
 }