1 files changed, 265 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js
new file mode 100644
index 0000000000..4c88f44608
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexVerifierUtil.js
@@ -0,0 +1,265 @@
+/*-------------------------------------------------------------------------
+ * drawElements Quality Program OpenGL ES Utilities
+ * ------------------------------------------------
+ *
+ * Copyright 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+'use strict';
+goog.provide('framework.common.tcuTexVerifierUtil');
+goog.require('framework.common.tcuFloat');
+goog.require('framework.common.tcuTexture');
+goog.require('framework.delibs.debase.deMath');
+goog.require('framework.delibs.debase.deUtil');
+
+goog.scope(function() {
+
+    var tcuTexVerifierUtil = framework.common.tcuTexVerifierUtil;
+    var deMath = framework.delibs.debase.deMath;
+    var deUtil = framework.delibs.debase.deUtil;
+    var tcuFloat = framework.common.tcuFloat;
+    var tcuTexture = framework.common.tcuTexture;
+
+    /**
+     * @param {number} value
+     * @param {number} numAccurateBits
+     * @return {number}
+     */
+    tcuTexVerifierUtil.computeFloatingPointError = function(value, numAccurateBits) {
+        /** @type {number} */ var numGarbageBits = 23 - numAccurateBits;
+        /** @type {number} */ var mask = (1 << numGarbageBits) - 1;
+        /** @type {number} */ var exp = tcuFloat.newFloat32(value).exponent();
+
+        /** @type {tcuFloat.deFloat} */ var v1 = new tcuFloat.deFloat();
+        /** @type {tcuFloat.deFloat} */ var v2 = new tcuFloat.deFloat();
+        return v1.construct(1, exp, 1 << 23 | mask).getValue() - v2.construct(1, exp, 1 << 23).getValue();
+    };
+
+    /**
+     * @param {number} numAccurateBits
+     * @return {number}
+     */
+    tcuTexVerifierUtil.computeFixedPointError = function(numAccurateBits) {
+        return tcuTexVerifierUtil.computeFloatingPointError(1.0, numAccurateBits);
+    };
+
+    /**
+     * @param {Array<number>} numAccurateBits
+     * @return {Array<number>}
+     */
+    tcuTexVerifierUtil.computeFixedPointError_Vector = function(numAccurateBits) {
+        /** @type {Array<number>} */ var res = [];
+        for (var ndx = 0; ndx < numAccurateBits.length; ndx++)
+            res[ndx] = tcuTexVerifierUtil.computeFixedPointError(numAccurateBits[ndx]);
+        return res;
+    };
+
+    /**
+     * @param {Array<number>} value
+     * @param {Array<number>} numAccurateBits
+     * @return {Array<number>}
+     */
+    tcuTexVerifierUtil.computeFloatingPointError_Vector = function(value, numAccurateBits) {
+        assertMsgOptions(value.length === numAccurateBits.length, '', false, true);
+        /** @type {Array<number>} */ var res = [];
+        for (var ndx = 0; ndx < value.length; ndx++)
+            res[ndx] = tcuTexVerifierUtil.computeFloatingPointError(value[ndx], numAccurateBits[ndx]);
+        return res;
+    };
+
+    // Sampler introspection
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isNearestMipmapFilter = function(mode) {
+        return mode == tcuTexture.FilterMode.NEAREST_MIPMAP_NEAREST || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_NEAREST;
+    };
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isLinearMipmapFilter = function(mode) {
+        return mode == tcuTexture.FilterMode.NEAREST_MIPMAP_LINEAR || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_LINEAR;
+    };
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isMipmapFilter = function(mode) {
+        return tcuTexVerifierUtil.isNearestMipmapFilter(mode) || tcuTexVerifierUtil.isLinearMipmapFilter(mode);
+    };
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isLinearFilter = function(mode) {
+        return mode == tcuTexture.FilterMode.LINEAR || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_NEAREST || mode == tcuTexture.FilterMode.LINEAR_MIPMAP_LINEAR;
+    };
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isNearestFilter = function(mode) {
+        return !tcuTexVerifierUtil.isLinearFilter(mode);
+    };
+
+    /**
+     * @param {tcuTexture.FilterMode} mode
+     * @return {tcuTexture.FilterMode}
+     */
+     tcuTexVerifierUtil.getLevelFilter = function(mode) {
+        return tcuTexVerifierUtil.isLinearFilter(mode) ? tcuTexture.FilterMode.LINEAR : tcuTexture.FilterMode.NEAREST;
+    };
+
+    /**
+     * @param {tcuTexture.WrapMode} mode
+     * @return {boolean}
+     */
+    tcuTexVerifierUtil.isWrapModeSupported = function(mode) {
+        return mode != tcuTexture.WrapMode.MIRRORED_REPEAT_CL && mode != tcuTexture.WrapMode.REPEAT_CL;
+    };
+
+    /**
+     *
+     * @param {boolean} normalizedCoords
+     * @param {number} dim
+     * @param {number} coord
+     * @param {number} coordBits
+     * @param {number} uvBits
+     * @return {Array<number>}
+     */
+    tcuTexVerifierUtil.computeNonNormalizedCoordBounds = function(normalizedCoords, dim, coord, coordBits, uvBits) {
+        /** @type {number} */ var coordErr = tcuTexVerifierUtil.computeFloatingPointError(coord, coordBits);
+        /** @type {number} */ var minN = coord - coordErr;
+        /** @type {number} */ var maxN = coord + coordErr;
+        /** @type {number} */ var minA = normalizedCoords ? minN * dim : minN;
+        /** @type {number} */ var maxA = normalizedCoords ? maxN * dim : maxN;
+        /** @type {number} */ var minC = minA - tcuTexVerifierUtil.computeFixedPointError(uvBits);
+        /** @type {number} */ var maxC = maxA + tcuTexVerifierUtil.computeFixedPointError(uvBits);
+        assertMsgOptions(minC <= maxC, '', false, true);
+        return [minC, maxC];
+    };
+
+    /**
+     * @param {Array<number>} coord
+     * @param {Array<number>} bits
+     * @return {?Array<tcuTexture.CubeFace>}
+     */
+     tcuTexVerifierUtil.getPossibleCubeFaces = function(coord, bits) {
+
+        /** @type {Array<tcuTexture.CubeFace>} */ var faces = [];
+
+        /** @type {number} */ var x = coord[0];
+        /** @type {number} */ var y = coord[1];
+        /** @type {number} */ var z = coord[2];
+        /** @type {number} */ var ax = Math.abs(x);
+        /** @type {number} */ var ay = Math.abs(y);
+        /** @type {number} */ var az = Math.abs(z);
+        /** @type {number} */ var ex = tcuTexVerifierUtil.computeFloatingPointError(x, bits[0]);
+        /** @type {number} */ var ey = tcuTexVerifierUtil.computeFloatingPointError(y, bits[1]);
+        /** @type {number} */ var ez = tcuTexVerifierUtil.computeFloatingPointError(z, bits[2]);
+        /** @type {number} */ var numFaces = 0;
+
+        if (ay + ey < ax - ex && az + ez < ax - ex) {
+            if (x >= ex) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_X);
+            if (x <= ex) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X);
+        } else if (ax + ex < ay - ey && az + ez < ay - ey) {
+            if (y >= ey) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y);
+            if (y <= ey) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y);
+        } else if (ax + ex < az - ez && ay + ey < az - ez) {
+            if (z >= ez) faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z);
+            if (z <= ez) faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z);
+        } else {
+            // One or more components are equal (or within error bounds). Allow all faces where major axis is not zero.
+            if (ax > ex) {
+                faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X);
+                faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_X);
+            }
+
+            if (ay > ey) {
+                faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y);
+                faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y);
+            }
+
+            if (az > ez) {
+                faces.push(tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z);
+                faces.push(tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z);
+            }
+        }
+
+        return faces.length == 0 ? null : faces;
+    };
+
+    /**
+     * @param {tcuTexture.Sampler} sampler
+     * @return {tcuTexture.Sampler}
+     */
+    tcuTexVerifierUtil.getUnnormalizedCoordSampler = function(sampler) {
+        var copy = /** @type {tcuTexture.Sampler} */ (deUtil.clone(sampler));
+        copy.normalizedCoords = false;
+        return copy;
+    };
+
+    /**
+     * @param {number} a
+     * @param {number} b
+     * @return {number}
+     */
+    tcuTexVerifierUtil.imod = function(a, b) {
+        return deMath.imod(a, b);
+    };
+
+    /**
+     * @param {number} a
+     * @return {number}
+     */
+    tcuTexVerifierUtil.mirror = function(a) {
+        return deMath.mirror(a);
+    };
+
+    /**
+     * @param {tcuTexture.WrapMode} mode
+     * @param {number} c
+     * @param {number} size
+     * @return {number}
+     */
+    tcuTexVerifierUtil.wrap = function(mode, c, size) {
+        switch (mode) {
+            // \note CL and GL modes are handled identically here, as verification process accounts for
+            //         accuracy differences caused by different methods (wrapping vs. denormalizing first).
+            case tcuTexture.WrapMode.CLAMP_TO_EDGE:
+                return deMath.clamp(c, 0, size - 1);
+
+            case tcuTexture.WrapMode.REPEAT_GL:
+            case tcuTexture.WrapMode.REPEAT_CL:
+                return deMath.imod(c, size);
+
+            case tcuTexture.WrapMode.MIRRORED_REPEAT_GL:
+            case tcuTexture.WrapMode.MIRRORED_REPEAT_CL:
+                return (size - 1) - deMath.mirror(deMath.imod(c, 2 * size) - size);
+
+            default:
+                throw new Error('Wrap mode not supported.');
+        }
+    };
+
+});