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

Commit 7e893e1d authored by Stephen Hines's avatar Stephen Hines
Browse files

Add missing functions to math library. 

This also updates the math test suite to exercise all the basic operator
functions (except __udivsi3 which may not be 100% necessary). There is also a
small fix for rsQuaternionMultiply().

Change-Id: Id157e6d5ebe2e20c17e8ea7b13ffaa74c241838c
b: 3203577
parent da6f9295

libs/rs/java/tests/src/com/android/rs/test/math.rs

+140 −0
Original line number Diff line number Diff line
@@ -12,6 +12,31 @@ volatile int2 i2; 
volatile int3 i3;

volatile int4 i4;



volatile uint ui1;

volatile uint2 ui2;

volatile uint3 ui3;

volatile uint4 ui4;



volatile short s1;

volatile short2 s2;

volatile short3 s3;

volatile short4 s4;



volatile ushort us1;

volatile ushort2 us2;

volatile ushort3 us3;

volatile ushort4 us4;



volatile char c1;

volatile char2 c2;

volatile char3 c3;

volatile char4 c4;



volatile uchar uc1;

volatile uchar2 uc2;

volatile uchar3 uc3;

volatile uchar4 uc4;



#define TEST_FN_FUNC_FN(fnc)        \

    rsDebug("Testing " #fnc, 0);    \

    f1 = fnc(f1);                   \
@@ -168,9 +193,124 @@ static bool test_fp_math(uint32_t index) { 
    return failed;

}



#define DECL_INT(prefix)            \

volatile char prefix##_c_1 = 1;     \

volatile char2 prefix##_c_2 = 1;    \

volatile char3 prefix##_c_3 = 1;    \

volatile char4 prefix##_c_4 = 1;    \

volatile uchar prefix##_uc_1 = 1;   \

volatile uchar2 prefix##_uc_2 = 1;  \

volatile uchar3 prefix##_uc_3 = 1;  \

volatile uchar4 prefix##_uc_4 = 1;  \

volatile short prefix##_s_1 = 1;    \

volatile short2 prefix##_s_2 = 1;   \

volatile short3 prefix##_s_3 = 1;   \

volatile short4 prefix##_s_4 = 1;   \

volatile ushort prefix##_us_1 = 1;  \

volatile ushort2 prefix##_us_2 = 1; \

volatile ushort3 prefix##_us_3 = 1; \

volatile ushort4 prefix##_us_4 = 1; \

volatile int prefix##_i_1 = 1;      \

volatile int2 prefix##_i_2 = 1;     \

volatile int3 prefix##_i_3 = 1;     \

volatile int4 prefix##_i_4 = 1;     \

volatile uint prefix##_ui_1 = 1;    \

volatile uint2 prefix##_ui_2 = 1;   \

volatile uint3 prefix##_ui_3 = 1;   \

volatile uint4 prefix##_ui_4 = 1;   \

volatile long prefix##_l_1 = 1;     \

volatile ulong prefix##_ul_1 = 1;



#define TEST_INT_OP_TYPE(op, type)                      \

rsDebug("Testing " #op " for " #type "1", i++);         \

res_##type##_1 = src1_##type##_1 op src2_##type##_1;    \

rsDebug("Testing " #op " for " #type "2", i++);         \

res_##type##_2 = src1_##type##_2 op src2_##type##_2;    \

rsDebug("Testing " #op " for " #type "3", i++);         \

res_##type##_3 = src1_##type##_3 op src2_##type##_3;    \

rsDebug("Testing " #op " for " #type "4", i++);         \

res_##type##_4 = src1_##type##_4 op src2_##type##_4;



#define TEST_INT_OP(op)                     \

TEST_INT_OP_TYPE(op, c)                     \

TEST_INT_OP_TYPE(op, uc)                    \

TEST_INT_OP_TYPE(op, s)                     \

TEST_INT_OP_TYPE(op, us)                    \

TEST_INT_OP_TYPE(op, i)                     \

TEST_INT_OP_TYPE(op, ui)                    \

rsDebug("Testing " #op " for l1", i++);     \

res_l_1 = src1_l_1 op src2_l_1;             \

rsDebug("Testing " #op " for ul1", i++);    \

res_ul_1 = src1_ul_1 op src2_ul_1;



DECL_INT(res)

DECL_INT(src1)

DECL_INT(src2)



static bool test_basic_operators() {

    bool failed = false;

    int i = 0;



    TEST_INT_OP(+);

    TEST_INT_OP(-);

    TEST_INT_OP(*);

    TEST_INT_OP(/);

    TEST_INT_OP(%);

    TEST_INT_OP(<<);

    TEST_INT_OP(>>);



    if (failed) {

        rsDebug("test_basic_operators FAILED", 0);

    }

    else {

        rsDebug("test_basic_operators PASSED", 0);

    }



    return failed;

}



#define TEST_CVT(to, from, type)                        \

rsDebug("Testing convert from " #from " to " #to, 0);   \

to##1 = from##1;                                        \

to##2 = convert_##type##2(from##2);                     \

to##3 = convert_##type##3(from##3);                     \

to##4 = convert_##type##4(from##4);



#define TEST_CVT_MATRIX(to, type)   \

TEST_CVT(to, c, type);              \

TEST_CVT(to, uc, type);             \

TEST_CVT(to, s, type);              \

TEST_CVT(to, us, type);             \

TEST_CVT(to, i, type);              \

TEST_CVT(to, ui, type);             \

TEST_CVT(to, f, type);              \



static bool test_convert() {

    bool failed = false;



    TEST_CVT_MATRIX(c, char);

    TEST_CVT_MATRIX(uc, uchar);

    TEST_CVT_MATRIX(s, short);

    TEST_CVT_MATRIX(us, ushort);

    TEST_CVT_MATRIX(i, int);

    TEST_CVT_MATRIX(ui, uint);

    TEST_CVT_MATRIX(f, float);



    if (failed) {

        rsDebug("test_convert FAILED", 0);

    }

    else {

        rsDebug("test_convert PASSED", 0);

    }



    return failed;

}



void math_test(uint32_t index, int test_num) {

    bool failed = false;

    failed |= test_convert();

    failed |= test_fp_math(index);

    failed |= test_basic_operators();



    if (failed) {

        rsSendToClientBlocking(RS_MSG_TEST_FAILED);

libs/rs/rsScriptC_Lib.cpp

+10 −0
Original line number Diff line number Diff line
@@ -305,6 +305,14 @@ int SC_modsi3(int a, int b) { 
    return a % b;

}



unsigned int SC_udivsi3(unsigned int a, unsigned int b) {

    return a / b;

}



unsigned int SC_umodsi3(unsigned int a, unsigned int b) {

    return a % b;

}



int SC_getAllocation(const void *ptr) {

    GET_TLS();

    const Allocation *alloc = sc->ptrToAllocation(ptr);
@@ -363,6 +371,8 @@ void SC_ForEach2(RsScript vs, 
static ScriptCState::SymbolTable_t gSyms[] = {

    { "__divsi3", (void *)&SC_divsi3, true },

    { "__modsi3", (void *)&SC_modsi3, true },

    { "__udivsi3", (void *)&SC_udivsi3, true },

    { "__umodsi3", (void *)&SC_umodsi3, true },



    // allocation

    { "_Z19rsAllocationGetDimX13rs_allocation", (void *)&SC_allocGetDimX, true },

libs/rs/scriptc/rs_core.rsh

+1 −1
Original line number Diff line number Diff line
@@ -683,7 +683,7 @@ _RS_STATIC void __attribute__((overloadable)) 
rsQuaternionMultiply(rs_quaternion *q, const rs_quaternion *rhs) {

    q->w = -q->x*rhs->x - q->y*rhs->y - q->z*rhs->z + q->w*rhs->w;

    q->x =  q->x*rhs->w + q->y*rhs->z - q->z*rhs->y + q->w*rhs->x;

    q->y = -q->x*rhs->z + q->y*rhs->w + q->z*rhs->z + q->w*rhs->y;

    q->y = -q->x*rhs->z + q->y*rhs->w + q->z*rhs->x + q->w*rhs->y;

    q->z =  q->x*rhs->y - q->y*rhs->x + q->z*rhs->w + q->w*rhs->z;

}