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

Commit fae3f6b4 authored by Jason Sams's avatar Jason Sams
Browse files

Add matrix ops to RSH headers. 

Change-Id: I7e2843983a12e0155114b4a18813799e4341d26f
parent 0ebd5690

graphics/java/android/renderscript/FieldPacker.java

+1 −1
Original line number Diff line number Diff line
@@ -244,7 +244,7 @@ public class FieldPacker { 
        addU32(v.w);

    }



    public void addBoolean(Boolean v) {

    public void addBoolean(boolean v) {

        addI8((byte)(v ? 1 : 0));

    }

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

+38 −71
Original line number Diff line number Diff line
@@ -4,6 +4,9 @@ 
#include "../../../../scriptc/rs_math.rsh"

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



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





#define MAX_RADIUS 25



int height;
@@ -32,7 +35,7 @@ static float overInWMinInB; 


// Store our coefficients here

static float gaussian[MAX_RADIUS * 2 + 1];

static float colorMat[4][4];

static rs_matrix3x3 colorMat;



static void computeColorMatrix() {

    // Saturation
@@ -48,17 +51,15 @@ static void computeColorMatrix() { 


    float oneMinusS = 1.0f - saturation;



    rsMatrixLoadIdentity((rs_matrix4x4 *)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;

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



    inWMinInB = inWhite - inBlack;

    outWMinOutB = outWhite - outBlack;
@@ -107,48 +108,10 @@ static void computeGaussianWeights() { 


// This needs to be inline

static float4 levelsSaturation(float4 currentPixel) {

#if 0

    // 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) * overInWMinInB, gamma) * outWMinOutB + outBlack;

    currentPixel.y = pow( (currentPixel.y - inBlack) * overInWMinInB, gamma) * outWMinOutB + outBlack;

    currentPixel.z = pow( (currentPixel.z - inBlack) * overInWMinInB, 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;

#else

    float3 temp;

    // Color matrix multiply

    temp.x = colorMat[0][0] * currentPixel.x + colorMat[1][0] * currentPixel.y + colorMat[2][0] * currentPixel.z;

    temp.y = colorMat[0][1] * currentPixel.x + colorMat[1][1] * currentPixel.y + colorMat[2][1] * currentPixel.z;

    temp.z = colorMat[0][2] * currentPixel.x + colorMat[1][2] * currentPixel.y + colorMat[2][2] * currentPixel.z;

    float3 temp = rsMatrixMultiply(&colorMat, currentPixel.xyz);

    temp = (clamp(temp, 0.1f, 255.f) - inBlack) * overInWMinInB;

    temp = pow(temp, (float3)gamma);

    currentPixel.xyz = clamp(temp * outWMinOutB + outBlack, 0.1f, 255.f);

#endif



    return currentPixel;

}
@@ -188,8 +151,10 @@ static void horizontalBlur() { 
    // Horizontal blur

    int w, h, r;

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

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

        uchar4 *input = InPixel + h*width;

        uchar4 *output = ScratchPixel + h*width;



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

            blurredPixel = 0;



            for(r = -radius; r <= radius; r ++) {
@@ -202,23 +167,22 @@ static void horizontalBlur() { 
                if(validW > width - 1) {

                    validW = width - 1;

                }



                uchar4 *input = InPixel + h*width + validW;

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



                float weight = gaussian[r + radius];

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

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

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

                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;

            }



            uchar4 *output = ScratchPixel + h*width + w;

            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++;

        }

    }

}
@@ -229,8 +193,9 @@ static void horizontalBlurLevels() { 
    // Horizontal blur

    int w, h, r;

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

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

        uchar4 *output = OutPixel + h*width;



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

            blurredPixel = 0;



            for(r = -radius; r <= radius; r ++) {
@@ -243,6 +208,7 @@ static void horizontalBlurLevels() { 
                if(validW > width - 1) {

                    validW = width - 1;

                }

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



                uchar4 *input = InPixel + h*width + validW;
@@ -252,16 +218,16 @@ static void horizontalBlurLevels() { 
                currentPixel.z = (float)(input->z);

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



                blurredPixel += currentPixel*weight;

                blurredPixel.xyz += currentPixel.xyz * weight;

            }



            blurredPixel = levelsSaturation(blurredPixel);



            uchar4 *output = ScratchPixel + h*width + w;

            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++;

        }

    }

}
@@ -272,10 +238,13 @@ static void verticalBlur() { 
    // 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) {
@@ -292,17 +261,21 @@ static void verticalBlur() { 
                currentPixel.x = (float)(input->x);

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

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

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



                blurredPixel += currentPixel*weight;

                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

            }



            uchar4 *output = OutPixel + h*width + w;



            //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++;

        }

    }

}
@@ -311,12 +284,6 @@ void filter() { 
    RS_DEBUG(height);

    RS_DEBUG(width);

    RS_DEBUG(radius);

    RS_DEBUG(inBlack);

    RS_DEBUG(outBlack);

    RS_DEBUG(inWhite);

    RS_DEBUG(outWhite);

    RS_DEBUG(gamma);

    RS_DEBUG(saturation);



    computeColorMatrix();

libs/rs/rsScriptC_Lib.cpp

+0 −196
Original line number Diff line number Diff line
@@ -32,133 +32,6 @@ using namespace android::renderscript; 
    ScriptC * sc = (ScriptC *) tls->mScript









//////////////////////////////////////////////////////////////////////////////

// Non-Updated code below

//////////////////////////////////////////////////////////////////////////////



typedef struct {

    float x;

    float y;

    float z;

} vec3_t;



typedef struct {

    float x;

    float y;

    float z;

    float w;

} vec4_t;



typedef struct {

    float x;

    float y;

} vec2_t;





//////////////////////////////////////////////////////////////////////////////

// Vec3 routines

//////////////////////////////////////////////////////////////////////////////



static void SC_vec3Norm(vec3_t *v)

{

    float len = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z);

    len = 1 / len;

    v->x *= len;

    v->y *= len;

    v->z *= len;

}



static float SC_vec3Length(const vec3_t *v)

{

    return sqrtf(v->x * v->x + v->y * v->y + v->z * v->z);

}



static void SC_vec3Add(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs)

{

    dest->x = lhs->x + rhs->x;

    dest->y = lhs->y + rhs->y;

    dest->z = lhs->z + rhs->z;

}



static void SC_vec3Sub(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs)

{

    dest->x = lhs->x - rhs->x;

    dest->y = lhs->y - rhs->y;

    dest->z = lhs->z - rhs->z;

}



static void SC_vec3Cross(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs)

{

    float x = lhs->y * rhs->z  - lhs->z * rhs->y;

    float y = lhs->z * rhs->x  - lhs->x * rhs->z;

    float z = lhs->x * rhs->y  - lhs->y * rhs->x;

    dest->x = x;

    dest->y = y;

    dest->z = z;

}



static float SC_vec3Dot(const vec3_t *lhs, const vec3_t *rhs)

{

    return lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z;

}



static void SC_vec3Scale(vec3_t *lhs, float scale)

{

    lhs->x *= scale;

    lhs->y *= scale;

    lhs->z *= scale;

}



//////////////////////////////////////////////////////////////////////////////

// Vec4 routines

//////////////////////////////////////////////////////////////////////////////



static void SC_vec4Norm(vec4_t *v)

{

    float len = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z + v->w * v->w);

    len = 1 / len;

    v->x *= len;

    v->y *= len;

    v->z *= len;

    v->w *= len;

}



static float SC_vec4Length(const vec4_t *v)

{

    return sqrtf(v->x * v->x + v->y * v->y + v->z * v->z + v->w * v->w);

}



static void SC_vec4Add(vec4_t *dest, const vec4_t *lhs, const vec4_t *rhs)

{

    dest->x = lhs->x + rhs->x;

    dest->y = lhs->y + rhs->y;

    dest->z = lhs->z + rhs->z;

    dest->w = lhs->w + rhs->w;

}



static void SC_vec4Sub(vec4_t *dest, const vec4_t *lhs, const vec4_t *rhs)

{

    dest->x = lhs->x - rhs->x;

    dest->y = lhs->y - rhs->y;

    dest->z = lhs->z - rhs->z;

    dest->w = lhs->w - rhs->w;

}



static float SC_vec4Dot(const vec4_t *lhs, const vec4_t *rhs)

{

    return lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z + lhs->w * rhs->w;

}



static void SC_vec4Scale(vec4_t *lhs, float scale)

{

    lhs->x *= scale;

    lhs->y *= scale;

    lhs->z *= scale;

    lhs->w *= scale;

}



//////////////////////////////////////////////////////////////////////////////

// Math routines

//////////////////////////////////////////////////////////////////////////////
@@ -224,41 +97,6 @@ static int SC_randi2(int min, int max) 
    return (int)SC_randf2(min, max);

}



static int SC_clamp(int amount, int low, int high)

{

    return amount < low ? low : (amount > high ? high : amount);

}



static float SC_roundf(float v)

{

    return floorf(v + 0.4999999999);

}



static float SC_distf2(float x1, float y1, float x2, float y2)

{

    float x = x2 - x1;

    float y = y2 - y1;

    return sqrtf(x * x + y * y);

}



static float SC_distf3(float x1, float y1, float z1, float x2, float y2, float z2)

{

    float x = x2 - x1;

    float y = y2 - y1;

    float z = z2 - z1;

    return sqrtf(x * x + y * y + z * z);

}



static float SC_magf2(float a, float b)

{

    return sqrtf(a * a + b * b);

}



static float SC_magf3(float a, float b, float c)

{

    return sqrtf(a * a + b * b + c * c);

}



static float SC_frac(float v)

{

    int i = (int)floor(v);
@@ -512,24 +350,6 @@ static void SC_debugI32(const char *s, int32_t i) { 
    LOGE("%s %i  0x%x", s, i, i);

}



static uchar4 SC_convertColorTo8888_f3(float r, float g, float b) {

    uchar4 t;

    t.f[0] = (uint8_t)(r * 255.f);

    t.f[1] = (uint8_t)(g * 255.f);

    t.f[2] = (uint8_t)(b * 255.f);

    t.f[3] = 0xff;

    return t;

}



static uchar4 SC_convertColorTo8888_f4(float r, float g, float b, float a) {

    uchar4 t;

    t.f[0] = (uint8_t)(r * 255.f);

    t.f[1] = (uint8_t)(g * 255.f);

    t.f[2] = (uint8_t)(b * 255.f);

    t.f[3] = (uint8_t)(a * 255.f);

    return t;

}



static uint32_t SC_toClient(void *data, int cmdID, int len, int waitForSpace)

{

    GET_TLS();
@@ -640,16 +460,6 @@ static ScriptCState::SymbolTable_t gSyms[] = { 
    { "rsAllocationGetDimFaces", (void *)&SC_allocGetDimFaces },

    { "rsGetAllocation", (void *)&SC_getAllocation },



    // color

    { "_Z17rsPackColorTo8888fff", (void *)&SC_convertColorTo8888_f3 },

    { "_Z17rsPackColorTo8888ffff", (void *)&SC_convertColorTo8888_f4 },

    //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float3);

    //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float4);

    //extern float4 rsUnpackColor8888(uchar4);

    //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float r, float g, float b);

    //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float3);

    //extern float4 rsUnpackColor565(uchar4);



    // Debug

    { "_Z7rsDebugPKcf", (void *)&SC_debugF },

    { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugFv2 },
@@ -703,12 +513,6 @@ static ScriptCState::SymbolTable_t gSyms[] = { 


    //{ "sinf_fast", (void *)&SC_sinf_fast },

    //{ "cosf_fast", (void *)&SC_cosf_fast },

    //{ "clamp", (void *)&SC_clamp },

    //{ "distf2", (void *)&SC_distf2 },

    //{ "distf3", (void *)&SC_distf3 },

    //{ "magf2", (void *)&SC_magf2 },

    //{ "magf3", (void *)&SC_magf3 },

    //{ "mapf", (void *)&SC_mapf },



    { "scriptCall", (void *)&SC_scriptCall },

libs/rs/scriptc/rs_core.rsh

+451 −0

File changed.

Preview size limit exceeded, changes collapsed.