Add missing functions and tests for support library.

Missing functions:
rsFrac(float)
rsMatrixLoadRotate(rs_matrix4x4 *, float, float, float, float)
rsMatrixLoadScale(rs_matrix4x4 *, float, float, float)
rsMatrixLoadTranslate(rs_matrix4x4 *, float, float, float)
rsMatrixRotate(rs_matrix4x4 *, float, float, float, float)
rsMatrixScale(rs_matrix4x4 *, float, float, float)
rsMatrixTranslate(rs_matrix4x4 *, float, float, float)
rsMatrixLoadOrtho(rs_matrix4x4 *, float, float, float, float, float, float)
rsMatrixLoadFrustum(rs_matrix4x4 *, float, float, float, float, float, float)
rsMatrixLoadPerspective(rs_matrix4x4 *, float, float, float, float)
rsMatrixInverse(rs_matrix4x4 *)
rsMatrixInverseTranspose(rs_matrix4x4 *)
rsMatrixTranspose(rs_matrix4x4 *)
rsMatrixTranspose(rs_matrix3x3 *)
rsMatrixTranspose(rs_matrix2x2 *)
rsUptimeNanos()
rsGetDt()

Headers tested in this CL:
rs_element.rsh
rs_math.rsh
rs_matrix.rsh
rs_object.rsh
rs_sampler.rsh
rs_time.rsh

Change-Id: I6cb1972a44f66dc7fed8fe3cf0329720d166af81

4 files changed, 192 insertions, 3 deletions

diff --git a/cpu_ref/rsCpuRuntimeMath.cpp b/cpu_ref/rsCpuRuntimeMath.cpp
index 0aaadd44..66bd576e 100644
--- a/cpu_ref/rsCpuRuntimeMath.cpp
+++ b/cpu_ref/rsCpuRuntimeMath.cpp
@@ -159,6 +159,60 @@ EXPORT_F32_FN_F32(sqrtf)
 EXPORT_F32_FN_F32(tanf)
 EXPORT_F32_FN_F32(tanhf)
 EXPORT_F32_FN_F32(truncf)
+float __attribute__((overloadable)) rsFrac(float f) {
+    return SC_frac(f);
+}
+void __attribute__((overloadable)) rsMatrixLoadRotate(rs_matrix4x4 *m,
+        float rot, float x, float y, float z) {
+    SC_MatrixLoadRotate((Matrix4x4 *) m, rot, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixLoadScale(rs_matrix4x4 *m,
+        float x, float y, float z) {
+    SC_MatrixLoadScale((Matrix4x4 *) m, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixLoadTranslate(rs_matrix4x4 *m,
+        float x, float y, float z) {
+    SC_MatrixLoadTranslate((Matrix4x4 *) m, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixRotate(rs_matrix4x4 *m, float rot,
+        float x, float y, float z) {
+    SC_MatrixRotate((Matrix4x4 *) m, rot, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixScale(rs_matrix4x4 *m, float x,
+        float y, float z) {
+    SC_MatrixScale((Matrix4x4 *) m, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixTranslate(rs_matrix4x4 *m, float x,
+        float y, float z) {
+    SC_MatrixTranslate((Matrix4x4 *) m, x, y, z);
+}
+void __attribute__((overloadable)) rsMatrixLoadOrtho(rs_matrix4x4 *m, float l,
+        float r, float b, float t, float n, float f) {
+    SC_MatrixLoadOrtho((Matrix4x4 *) m, l, r, b, t, n, f);
+}
+void __attribute__((overloadable)) rsMatrixLoadFrustum(rs_matrix4x4 *m,
+        float l, float r, float b, float t, float n, float f) {
+    SC_MatrixLoadFrustum((Matrix4x4 *) m, l, r, b, t, n, f);
+}
+void __attribute__((overloadable)) rsMatrixLoadPerspective(rs_matrix4x4 *m,
+        float fovy, float aspect, float near, float far) {
+    SC_MatrixLoadPerspective((Matrix4x4 *) m, fovy, aspect, near, far);
+}
+bool __attribute__((overloadable)) rsMatrixInverse(rs_matrix4x4 *m) {
+    return SC_MatrixInverse_4x4((Matrix4x4 *) m);
+}
+bool __attribute__((overloadable)) rsMatrixInverseTranspose(rs_matrix4x4 *m) {
+    return SC_MatrixInverseTranspose_4x4((Matrix4x4 *) m);
+}
+void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix4x4 *m) {
+    SC_MatrixTranspose_4x4((Matrix4x4 *) m);
+}
+void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix3x3 *m) {
+    SC_MatrixTranspose_3x3((Matrix3x3 *) m);
+}
+void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix2x2 *m) {
+    SC_MatrixTranspose_2x2((Matrix2x2 *) m);
+}
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/driver/rsdRuntimeStubs.cpp b/driver/rsdRuntimeStubs.cpp
index 1b617cd1..cb5d008a 100644
--- a/driver/rsdRuntimeStubs.cpp
+++ b/driver/rsdRuntimeStubs.cpp
@@ -1323,6 +1323,14 @@ int64_t rsUptimeMillis() {
     return rsrUptimeMillis(rsc);
 }
 
+int64_t rsUptimeNanos() {
+    return SC_UptimeNanos();
+}
+
+float rsGetDt() {
+    return SC_GetDt();
+}
+
 uint32_t rsSendToClient(int cmdID) {
     return SC_ToClient(cmdID);
 }
diff --git a/java/tests/RSTest_CompatLib/src/com/android/rs/test/apitest.rs b/java/tests/RSTest_CompatLib/src/com/android/rs/test/apitest.rs
index 27753af4..865620f2 100644
--- a/java/tests/RSTest_CompatLib/src/com/android/rs/test/apitest.rs
+++ b/java/tests/RSTest_CompatLib/src/com/android/rs/test/apitest.rs
@@ -15,6 +15,14 @@ rs_sampler samplerNonNull;
 rs_script scriptNull;
 rs_script scriptNonNull;
 
+volatile rs_data_type dt;
+volatile rs_data_kind dk;
+
+volatile rs_sampler_value rsv;
+
+volatile rs_time_t rst;
+volatile static rs_tm rstm;
+
 char *allocPtr;
 rs_allocation allocDst;
 
@@ -61,6 +69,7 @@ volatile double d;
 volatile double2 d2;
 volatile double3 d3;
 volatile double4 d4;
+float fa[16];
 
 rs_allocation aChar;
 rs_allocation aChar2;
@@ -1163,6 +1172,121 @@ void check_api_presence() {
     rsDebug("", ul3);
     rsDebug("", ul4);
 
+    // rs_element.rsh
+    ui = rsElementGetSubElementCount(elemNonNull);
+    elemNull = rsElementGetSubElement(elemNonNull, 0);
+    ui = rsElementGetSubElementNameLength(elemNonNull, 0);
+    ui = rsElementGetSubElementName(elemNonNull, 0, NULL, 0);
+    ui = rsElementGetSubElementArraySize(elemNonNull, 0);
+    ui = rsElementGetSubElementOffsetBytes(elemNonNull, 0);
+    ui = rsElementGetBytesSize(elemNonNull);
+
+    dt = rsElementGetDataType(elemNonNull);
+    dk = rsElementGetDataKind(elemNonNull);
+
+    ui = rsElementGetVectorSize(elemNonNull);
+
+    // rs_math.rsh
+    i = rsRand(i);
+    i = rsRand(i, i);
+    f = rsRand(f);
+    f = rsFrac(f);
+    ui = rsClamp(ui, ui, ui);
+    i = rsClamp(i, i, i);
+    us = rsClamp(us, us, us);
+    s = rsClamp(s, s, s);
+    uc = rsClamp(uc, uc, uc);
+    c = rsClamp(c, c, c);
+
+    // skip always-inlined rsExtractFrustumPlanes
+    // skip always-inlined rsIsSphereInFrustum
+
+    uc4 = rsPackColorTo8888(f, f, f);
+    uc4 = rsPackColorTo8888(f, f, f, f);
+    uc4 = rsPackColorTo8888(f3);
+    uc4 = rsPackColorTo8888(f4);
+    f4 = rsUnpackColor8888(uc4);
+    uc4 = rsYuvToRGBA_uchar4(uc, uc, uc);
+    f4 = rsYuvToRGBA_float4(uc, uc, uc);
+
+    // rs_matrix.rsh
+    rsMatrixSet(&m4x4, ui, ui, f);
+    rsMatrixSet(&m3x3, ui, ui, f);
+    rsMatrixSet(&m2x2, ui, ui, f);
+    f = rsMatrixGet(&m4x4, ui, ui);
+    f = rsMatrixGet(&m3x3, ui, ui);
+    f = rsMatrixGet(&m2x2, ui, ui);
+    rsMatrixLoadIdentity(&m4x4);
+    rsMatrixLoadIdentity(&m3x3);
+    rsMatrixLoadIdentity(&m2x2);
+    rsMatrixLoad(&m4x4, fa);
+    rsMatrixLoad(&m3x3, fa);
+    rsMatrixLoad(&m2x2, fa);
+    rsMatrixLoad(&m4x4, &m4x4);
+    rsMatrixLoad(&m4x4, &m3x3);
+    rsMatrixLoad(&m4x4, &m2x2);
+    rsMatrixLoad(&m3x3, &m3x3);
+    rsMatrixLoad(&m2x2, &m2x2);
+    rsMatrixLoadRotate(&m4x4, f, f, f, f);
+    rsMatrixLoadScale(&m4x4, f, f, f);
+    rsMatrixLoadTranslate(&m4x4, f, f, f);
+    rsMatrixLoadMultiply(&m4x4, &m4x4, &m4x4);
+    rsMatrixLoadMultiply(&m3x3, &m3x3, &m3x3);
+    rsMatrixLoadMultiply(&m2x2, &m2x2, &m2x2);
+    rsMatrixMultiply(&m4x4, &m4x4);
+    rsMatrixMultiply(&m3x3, &m3x3);
+    rsMatrixMultiply(&m2x2, &m2x2);
+    rsMatrixRotate(&m4x4, f, f, f, f);
+    rsMatrixScale(&m4x4, f, f, f);
+    rsMatrixTranslate(&m4x4, f, f, f);
+    rsMatrixLoadOrtho(&m4x4, f, f, f, f, f, f);
+    rsMatrixLoadFrustum(&m4x4, f, f, f, f, f, f);
+    rsMatrixLoadPerspective(&m4x4, f, f, f, f);
+    f4 = rsMatrixMultiply(&m4x4, f4);
+    f4 = rsMatrixMultiply(&m4x4, f3);
+    f4 = rsMatrixMultiply(&m4x4, f2);
+    f3 = rsMatrixMultiply(&m3x3, f3);
+    f3 = rsMatrixMultiply(&m3x3, f2);
+    f2 = rsMatrixMultiply(&m2x2, f2);
+    b = rsMatrixInverse(&m4x4);
+    b = rsMatrixInverseTranspose(&m4x4);
+    rsMatrixTranspose(&m4x4);
+    rsMatrixTranspose(&m3x3);
+    rsMatrixTranspose(&m2x2);
+
+    // rs_object.rsh
+    rsSetObject(&elemNonNull, elemNonNull);
+    rsSetObject(&typeNonNull, typeNonNull);
+    rsSetObject(&allocNonNull, allocNonNull);
+    rsSetObject(&samplerNonNull, samplerNonNull);
+    rsSetObject(&scriptNonNull, scriptNonNull);
+    rsClearObject(&elemNonNull);
+    rsClearObject(&typeNonNull);
+    rsClearObject(&allocNonNull);
+    rsClearObject(&samplerNonNull);
+    rsClearObject(&scriptNonNull);
+    b = rsIsObject(elemNonNull);
+    b = rsIsObject(typeNonNull);
+    b = rsIsObject(allocNonNull);
+    b = rsIsObject(samplerNonNull);
+    b = rsIsObject(scriptNonNull);
+
+    // rs_quaternion.rsh skipped because all functions are static.
+
+    // rs_sampler.rsh
+    rsv = rsSamplerGetMinification(samplerNonNull);
+    rsv = rsSamplerGetMagnification(samplerNonNull);
+    rsv = rsSamplerGetWrapS(samplerNonNull);
+    rsv = rsSamplerGetWrapT(samplerNonNull);
+    f = rsSamplerGetAnisotropy(samplerNonNull);
+
+    // rs_time.rsh
+    rst = rsTime(NULL);
+    rsLocaltime((rs_tm *) &rstm, (rs_time_t *) &rst);
+    ll = rsUptimeMillis();
+    ll = rsUptimeNanos();
+    f = rsGetDt();
+
     /********************************
      * DO NOT EXECUTE THIS FUNCTION *
      ********************************/
diff --git a/rsScript.cpp b/rsScript.cpp
index 7857667c..a4a4e3ba 100644
--- a/rsScript.cpp
+++ b/rsScript.cpp
@@ -65,7 +65,8 @@ void Script::setVar(uint32_t slot, const void *val, size_t len) {
 void Script::getVar(uint32_t slot, const void *val, size_t len) {
     //ALOGE("getVar %i %p %i", slot, val, len);
     if (slot >= mHal.info.exportedVariableCount) {
-        ALOGE("Script::getVar unable to set allocation, invalid slot index");
+        ALOGE("Script::getVar unable to set allocation, invalid slot index: "
+              "%u >= %u", slot, mHal.info.exportedVariableCount);
         return;
     }
     mRSC->mHal.funcs.script.getGlobalVar(mRSC, this, slot, (void *)val, len);
@@ -74,7 +75,8 @@ void Script::getVar(uint32_t slot, const void *val, size_t len) {
 void Script::setVar(uint32_t slot, const void *val, size_t len, Element *e,
                     const size_t *dims, size_t dimLen) {
     if (slot >= mHal.info.exportedVariableCount) {
-        ALOGE("Script::setVar unable to set allocation, invalid slot index");
+        ALOGE("Script::setVar unable to set allocation, invalid slot index: "
+              "%u >= %u", slot, mHal.info.exportedVariableCount);
         return;
     }
     mRSC->mHal.funcs.script.setGlobalVarWithElemDims(mRSC, this, slot,
@@ -84,7 +86,8 @@ void Script::setVar(uint32_t slot, const void *val, size_t len, Element *e,
 void Script::setVarObj(uint32_t slot, ObjectBase *val) {
     //ALOGE("setVarObj %i %p", slot, val);
     if (slot >= mHal.info.exportedVariableCount) {
-        ALOGE("Script::setVarObj unable to set allocation, invalid slot index");
+        ALOGE("Script::setVarObj unable to set allocation, invalid slot index: "
+              "%u >= %u", slot, mHal.info.exportedVariableCount);
         return;
     }
     mHasObjectSlots = true;