Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 97e9ee2e authored by Jason Sams's avatar Jason Sams
Browse files

Cleanup blur test, remove deprecated functions. 

Change-Id: I4136110692fdba8a644806fe8c92bfaacc930ca6
parent 6704a48b

tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/Blur25.java

+15 −29
Original line number Diff line number Diff line
@@ -33,8 +33,6 @@ public class Blur25 extends TestBase { 


    private int MAX_RADIUS = 25;

    private ScriptC_threshold mScript;

    private ScriptC_vertical_blur mScriptVBlur;

    private ScriptC_horizontal_blur mScriptHBlur;

    private int mRadius = MAX_RADIUS;

    private float mSaturation = 1.0f;

    private Allocation mScratchPixelsAllocation1;
@@ -50,22 +48,17 @@ public class Blur25 extends TestBase { 
        b.setProgress(100);

        return true;

    }

    public boolean onBar2Setup(SeekBar b, TextView t) {

        b.setProgress(50);

        t.setText("Saturation");

        return true;

    }





    public void onBar1Changed(int progress) {

        float fRadius = progress / 100.0f;

        fRadius *= (float)(MAX_RADIUS);

        mRadius = (int)fRadius;

        mScript.set_radius(mRadius);

        if (mUseIntrinsic) {

            mIntrinsic.setRadius(mRadius);

        } else {

            mScript.invoke_setRadius(mRadius);

        }

    public void onBar2Changed(int progress) {

        mSaturation = (float)progress / 50.0f;

        mScriptVBlur.invoke_setSaturation(mSaturation);

    }
@@ -75,7 +68,7 @@ public class Blur25 extends TestBase { 


        if (mUseIntrinsic) {

            mIntrinsic = ScriptIntrinsicBlur.create(mRS, Element.U8_4(mRS));

            mIntrinsic.setRadius(25.f);

            mIntrinsic.setRadius(MAX_RADIUS);

            mIntrinsic.setInput(mInPixelsAllocation);

        } else {
@@ -85,23 +78,14 @@ public class Blur25 extends TestBase { 
            mScratchPixelsAllocation1 = Allocation.createTyped(mRS, tb.create());

            mScratchPixelsAllocation2 = Allocation.createTyped(mRS, tb.create());



            mScriptVBlur = new ScriptC_vertical_blur(mRS, res, R.raw.vertical_blur);

            mScriptHBlur = new ScriptC_horizontal_blur(mRS, res, R.raw.horizontal_blur);



            mScript = new ScriptC_threshold(mRS, res, R.raw.threshold);

            mScript.set_width(width);

            mScript.set_height(height);

            mScript.set_radius(mRadius);



            mScriptVBlur.invoke_setSaturation(mSaturation);



            mScript.bind_InPixel(mInPixelsAllocation);

            mScript.bind_OutPixel(mOutPixelsAllocation);

            mScript.bind_ScratchPixel1(mScratchPixelsAllocation1);

            mScript.bind_ScratchPixel2(mScratchPixelsAllocation2);

            mScript.invoke_setRadius(MAX_RADIUS);



            mScript.set_vBlurScript(mScriptVBlur);

            mScript.set_hBlurScript(mScriptHBlur);

            mScript.set_InPixel(mInPixelsAllocation);

            mScript.set_ScratchPixel1(mScratchPixelsAllocation1);

            mScript.set_ScratchPixel2(mScratchPixelsAllocation2);

        }

    }
@@ -109,7 +93,9 @@ public class Blur25 extends TestBase { 
        if (mUseIntrinsic) {

            mIntrinsic.forEach(mOutPixelsAllocation);

        } else {

            mScript.invoke_filter();

            mScript.forEach_copyIn(mInPixelsAllocation, mScratchPixelsAllocation1);

            mScript.forEach_horz(mScratchPixelsAllocation2);

            mScript.forEach_vert(mOutPixelsAllocation);

        }

    }
@@ -117,7 +103,7 @@ public class Blur25 extends TestBase { 
        if (mUseIntrinsic) {

            mIntrinsic.setRadius(MAX_RADIUS);

        } else {

            mScript.set_radius(MAX_RADIUS);

            mScript.invoke_setRadius(MAX_RADIUS);

        }

    }
@@ -125,7 +111,7 @@ public class Blur25 extends TestBase { 
        if (mUseIntrinsic) {

            mIntrinsic.setRadius(mRadius);

        } else {

            mScript.set_radius(mRadius);

            mScript.invoke_setRadius(mRadius);

        }

    }

}

tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs

deleted100644 → 0
+0 −28
Original line number Diff line number Diff line 
#pragma version(1)

#pragma rs_fp_relaxed



#include "ip.rsh"



void root(float4 *out, const void *usrData, uint32_t x, uint32_t y) {

    const FilterStruct *fs = (const FilterStruct *)usrData;

    float3 blurredPixel = 0;

    const float *gPtr = fs->gaussian;

    if ((x > fs->radius) && (x < (fs->width - fs->radius))) {

        for (int r = -fs->radius; r <= fs->radius; r ++) {

            const float4 *i = (const float4 *)rsGetElementAt(fs->ain, x + r, y);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    } else {

        for (int r = -fs->radius; r <= fs->radius; r ++) {

            // Stepping left and right away from the pixel

            int validX = rsClamp((int)x + r, (int)0, (int)(fs->width - 1));

            const float4 *i = (const float4 *)rsGetElementAt(fs->ain, validX, y);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    }



    out->xyz = blurredPixel;

}

tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ip.rsh

deleted100644 → 0
+0 −15
Original line number Diff line number Diff line 
#pragma rs java_package_name(com.android.rs.image)



#define MAX_RADIUS 25



typedef struct FilterStruct_s {

    rs_allocation ain;



    float *gaussian; //[MAX_RADIUS * 2 + 1];

    int height;

    int width;

    int radius;



} FilterStruct;

tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/threshold.rs

+51 −38
Original line number Diff line number Diff line 
#pragma version(1)

#pragma rs java_package_name(com.android.rs.image)

#pragma rs_fp_relaxed



#include "ip.rsh"



int height;

int width;

int radius;

static int radius;



uchar4 * InPixel;

uchar4 * OutPixel;

float4 * ScratchPixel1;

float4 * ScratchPixel2;

rs_allocation InPixel;

rs_allocation ScratchPixel1;

rs_allocation ScratchPixel2;



rs_script vBlurScript;

rs_script hBlurScript;



const int CMD_FINISHED = 1;

const int MAX_RADIUS = 25;



// Store our coefficients here

static float gaussian[MAX_RADIUS * 2 + 1];





static void computeGaussianWeights() {

void setRadius(int rad) {

    radius = rad;

    // Compute gaussian weights for the blur

    // e is the euler's number

    float e = 2.718281828459045f;
@@ -45,8 +42,7 @@ static void computeGaussianWeights() { 


    float normalizeFactor = 0.0f;

    float floatR = 0.0f;

    int r;

    for (r = -radius; r <= radius; r ++) {

    for (int r = -radius; r <= radius; r ++) {

        floatR = (float)r;

        gaussian[r + radius] = coeff1 * pow(e, floatR * floatR * coeff2);

        normalizeFactor += gaussian[r + radius];
@@ -54,40 +50,57 @@ static void computeGaussianWeights() { 


    //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 ++) {

    for (int r = -radius; r <= radius; r ++) {

        floatR = (float)r;

        gaussian[r + radius] *= normalizeFactor;

    }

}



void copyIn(const uchar4 *in, float4 *out) {

    *out = convert_float4(*in);

}



static void copyInput() {

    rs_allocation ain;

    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]);

void vert(uchar4 *out, uint32_t x, uint32_t y) {

    float3 blurredPixel = 0;

    const float *gPtr = gaussian;

    if ((y > radius) && (y < (height - radius))) {

        for (int r = -radius; r <= radius; r ++) {

            const float4 *i = (const float4 *)rsGetElementAt(ScratchPixel2, x, y + r);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    } else {

        for (int r = -radius; r <= radius; r ++) {

            int validH = rsClamp((int)y + r, (int)0, (int)(height - 1));

            const float4 *i = (const float4 *)rsGetElementAt(ScratchPixel2, x, validH);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    }



void filter() {

    copyInput();

    computeGaussianWeights();



    FilterStruct fs;

    fs.gaussian = gaussian;

    fs.width = width;

    fs.height = height;

    fs.radius = radius;

    out->xyz = convert_uchar3(clamp(blurredPixel, 0.f, 255.f));

    out->w = 0xff;

}



    fs.ain = rsGetAllocation(ScratchPixel1);

    rsForEach(hBlurScript, fs.ain, rsGetAllocation(ScratchPixel2), &fs, sizeof(fs));

void horz(float4 *out, uint32_t x, uint32_t y) {

    float3 blurredPixel = 0;

    const float *gPtr = gaussian;

    if ((x > radius) && (x < (width - radius))) {

        for (int r = -radius; r <= radius; r ++) {

            const float4 *i = (const float4 *)rsGetElementAt(ScratchPixel1, x + r, y);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    } else {

        for (int r = -radius; r <= radius; r ++) {

            // Stepping left and right away from the pixel

            int validX = rsClamp((int)x + r, (int)0, (int)(width - 1));

            const float4 *i = (const float4 *)rsGetElementAt(ScratchPixel1, validX, y);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    }



    fs.ain = rsGetAllocation(ScratchPixel2);

    rsForEach(vBlurScript, fs.ain, rsGetAllocation(OutPixel), &fs, sizeof(fs));

    //rsSendToClientBlocking(CMD_FINISHED);

    out->xyz = blurredPixel;

}

tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/vertical_blur.rs

deleted100644 → 0
+0 −59
Original line number Diff line number Diff line 
#pragma version(1)

#pragma rs_fp_relaxed



#include "ip.rsh"



static float saturation;

static rs_matrix3x3 colorMat;



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 root(uchar4 *out, const void *usrData, uint32_t x, uint32_t y) {

    const FilterStruct *fs = (const FilterStruct *)usrData;

    float3 blurredPixel = 0;

    const float *gPtr = fs->gaussian;

    if ((y > fs->radius) && (y < (fs->height - fs->radius))) {

        for (int r = -fs->radius; r <= fs->radius; r ++) {

            const float4 *i = (const float4 *)rsGetElementAt(fs->ain, x, y + r);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    } else {

        for (int r = -fs->radius; r <= fs->radius; r ++) {

            int validH = rsClamp((int)y + r, (int)0, (int)(fs->height - 1));

            const float4 *i = (const float4 *)rsGetElementAt(fs->ain, x, validH);

            blurredPixel += i->xyz * gPtr[0];

            gPtr++;

        }

    }



    float3 temp = rsMatrixMultiply(&colorMat, blurredPixel);

    temp = clamp(temp, 0.f, 255.f);

    out->xyz = convert_uchar3(temp);

    out->w = 0xff;

}