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

Commit 6ea3b2a5 authored by Jason Sams's avatar Jason Sams Committed by Android (Google) Code Review
Browse files

Merge "1st cut of ForEach and test."

parents de41684c 8f8a5724

libs/rs/RenderScript.h

+13 −0
Original line number Diff line number Diff line
@@ -255,6 +255,19 @@ typedef struct { 
    const char* objectName;

} RsFileIndexEntry;



// Script to Script

typedef struct {

    uint32_t xStart;

    uint32_t xEnd;

    uint32_t yStart;

    uint32_t yEnd;

    uint32_t zStart;

    uint32_t zEnd;

    uint32_t arrayStart;

    uint32_t arrayEnd;



} RsScriptCall;



#ifndef NO_RS_FUNCS

#include "rsgApiFuncDecl.h"

#endif

libs/rs/java/ImageProcessing/res/raw/horizontal_blur.rs

0 → 100644
+43 −0
Original line number Diff line number Diff line 
#pragma version(1)



#include "../../../../scriptc/rs_types.rsh"

#include "../../../../scriptc/rs_math.rsh"



#include "ip.rsh"



uchar4 * ScratchPixel;



#pragma rs export_var(ScratchPixel)



void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) {

    uchar4 *output = (uchar4 *)v_out;

    const uchar4 *input = (uchar4 *)v_in;

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



    float4 blurredPixel = 0;

    float4 currentPixel = 0;

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

        // Stepping left and right away from the pixel

        int validW = x + r;

        // Clamp to zero and width max() isn't exposed for ints yet

        if(validW < 0) {

            validW = 0;

        }

        if(validW > fs->width - 1) {

            validW = fs->width - 1;

        }

        //int validW = rsClamp(w + r, 0, width - 1);



        float weight = fs->gaussian[r + fs->radius];

        currentPixel.x = (float)(input[validW].x);

        currentPixel.y = (float)(input[validW].y);

        currentPixel.z = (float)(input[validW].z);

        //currentPixel.w = (float)(input->a);



        blurredPixel += currentPixel * weight;

    }



    output->x = (uint8_t)blurredPixel.x;

    output->y = (uint8_t)blurredPixel.y;

    output->z = (uint8_t)blurredPixel.z;

}

libs/rs/java/ImageProcessing/res/raw/horizontal_blur_bc.bc

0 → 100644
+1.29 KiB

File added.

No diff preview for this file type.

View file

libs/rs/java/ImageProcessing/res/raw/ip.rsh

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



#define MAX_RADIUS 25



typedef struct {

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

    rs_matrix3x3 colorMat;



    int height;

    int width;

    int radius;



} FilterStruct;

libs/rs/java/ImageProcessing/res/raw/threshold.rs

+29 −98
Original line number Diff line number Diff line
@@ -2,12 +2,8 @@ 


#include "../../../../scriptc/rs_types.rsh"

#include "../../../../scriptc/rs_math.rsh"

#include "../../../../scriptc/rs_graphics.rsh"



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





#define MAX_RADIUS 25

#include "ip.rsh"



int height;

int width;
@@ -28,11 +24,15 @@ float saturation; 
static float inWMinInB;

static float outWMinOutB;

static float overInWMinInB;

//static float3 gammaV;

static FilterStruct filterStruct;



#pragma rs export_var(height, width, radius, InPixel, OutPixel, ScratchPixel, inBlack, outBlack, inWhite, outWhite, gamma, saturation, InPixel, OutPixel, ScratchPixel)

#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(filter, filterBenchmark);



rs_script vBlurScript;

rs_script hBlurScript;





// Store our coefficients here

static float gaussian[MAX_RADIUS * 2 + 1];

static rs_matrix3x3 colorMat;
@@ -145,48 +145,6 @@ static void processNoBlur() { 
    rsSendToClient(&count, 1, 4, 0);

}



static void horizontalBlur() {

    float4 blurredPixel = 0;

    float4 currentPixel = 0;

    // Horizontal blur

    int w, h, r;

    for(h = 0; h < height; h ++) {

        uchar4 *input = InPixel + h*width;

        uchar4 *output = ScratchPixel + h*width;



        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;

                }

                //int validW = rsClamp(w + r, 0, width - 1);



                float weight = gaussian[r + radius];

                currentPixel.x = (float)(input[validW].x);

                currentPixel.y = (float)(input[validW].y);

                currentPixel.z = (float)(input[validW].z);

                //currentPixel.w = (float)(input->a);



                blurredPixel += currentPixel*weight;

            }



            output->x = (uint8_t)blurredPixel.x;

            output->y = (uint8_t)blurredPixel.y;

            output->z = (uint8_t)blurredPixel.z;

            //output->a = (uint8_t)blurredPixel.w;

            output++;

        }

    }

}



static void horizontalBlurLevels() {

    float4 blurredPixel = 0;

    float4 currentPixel = 0;
@@ -232,52 +190,11 @@ static void horizontalBlurLevels() { 
    }

}



static void verticalBlur() {

    float4 blurredPixel = 0;

    float4 currentPixel = 0;

    // Vertical blur

    int w, h, r;

    for(h = 0; h < height; h ++) {

        uchar4 *output = OutPixel + h*width;



        for(w = 0; w < width; w ++) {



            blurredPixel = 0;

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

#if 1

                int validH = h + r;

                // Clamp to zero and width

                if(validH < 0) {

                    validH = 0;

                }

                if(validH > height - 1) {

                    validH = height - 1;

                }



                uchar4 *input = ScratchPixel + validH*width + w;



                float weight = gaussian[r + radius];



                currentPixel.x = (float)(input->x);

                currentPixel.y = (float)(input->y);

                currentPixel.z = (float)(input->z);



                blurredPixel.xyz += currentPixel.xyz * weight;

#else

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

                uchar4 *input = ScratchPixel + validH*width + w;

                blurredPixel.xyz += convert_float3(input->xyz) * gaussian[r + radius];

#endif

            }



            //output->xyz = convert_uchar3(blurredPixel.xyz);

            output->x = (uint8_t)blurredPixel.x;

            output->y = (uint8_t)blurredPixel.y;

            output->z = (uint8_t)blurredPixel.z;

            //output->a = (uint8_t)blurredPixel.w;

            output++;

        }

    }

static void initStructs() {

    filterStruct.gaussian = gaussian;

    filterStruct.width = width;

    filterStruct.height = height;

    filterStruct.radius = radius;

}



void filter() {
@@ -285,6 +202,8 @@ void filter() { 
    RS_DEBUG(width);

    RS_DEBUG(radius);



    initStructs();



    computeColorMatrix();



    if(radius == 0) {
@@ -295,18 +214,30 @@ void filter() { 
    computeGaussianWeights();



    horizontalBlurLevels();

    verticalBlur();



    rsForEach(vBlurScript,

              rsGetAllocation(InPixel),

              rsGetAllocation(OutPixel),

              &filterStruct);



    int count = 0;

    rsSendToClient(&count, 1, 4, 0);

}



void filterBenchmark() {

    initStructs();



    computeGaussianWeights();



    horizontalBlur();

    verticalBlur();

    rsForEach(hBlurScript,

              rsGetAllocation(InPixel),

              rsGetAllocation(OutPixel),

              &filterStruct);



    rsForEach(vBlurScript,

              rsGetAllocation(InPixel),

              rsGetAllocation(OutPixel),

              &filterStruct);



    int count = 0;

    rsSendToClient(&count, 1, 4, 0);