/*-------------------------------------------------------------------------
 * 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.tcuTexCompareVerifier');
goog.require('framework.common.tcuTexVerifierUtil');
goog.require('framework.common.tcuTexture');
goog.require('framework.common.tcuTextureUtil');
goog.require('framework.delibs.debase.deMath');

goog.scope(function() {

var tcuTexCompareVerifier = framework.common.tcuTexCompareVerifier;
var tcuTexture = framework.common.tcuTexture;
var deMath = framework.delibs.debase.deMath;
var tcuTextureUtil = framework.common.tcuTextureUtil;
var tcuTexVerifierUtil = framework.common.tcuTexVerifierUtil;

/**
 * \brief Texture compare (shadow) lookup precision parameters.
 * @constructor
 * @struct
 * @param {Array<number>=} coordBits
 * @param {Array<number>=} uvwBits
 * @param {number=} pcfBits
 * @param {number=} referenceBits
 * @param {number=} resultBits
 */
tcuTexCompareVerifier.TexComparePrecision = function(coordBits, uvwBits, pcfBits, referenceBits, resultBits) {
    this.coordBits = coordBits === undefined ? [22, 22, 22] : coordBits;
    this.uvwBits = uvwBits === undefined ? [22, 22, 22] : uvwBits;
    this.pcfBits = pcfBits === undefined ? 16 : pcfBits;
    this.referenceBits = referenceBits === undefined ? 16 : referenceBits;
    this.resultBits = resultBits === undefined ? 16 : resultBits;
};

/**
 * @constructor
 * @struct
 */
tcuTexCompareVerifier.CmpResultSet = function() {
    this.isTrue = false;
    this.isFalse = false;
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {number} cmpValue_
 * @param {number} cmpReference_
 * @param {number} referenceBits
 * @param {boolean} isFixedPoint
 * @return {tcuTexCompareVerifier.CmpResultSet}
 */
tcuTexCompareVerifier.execCompare = function(compareMode,
                                 cmpValue_,
                                 cmpReference_,
                                 referenceBits,
                                 isFixedPoint) {
    var clampValues = isFixedPoint; // if comparing against a floating point texture, ref (and value) is not clamped
    var cmpValue = (clampValues) ? (deMath.clamp(cmpValue_, 0, 1)) : (cmpValue_);
    var cmpReference = (clampValues) ? (deMath.clamp(cmpReference_, 0, 1)) : (cmpReference_);
    var err = tcuTexVerifierUtil.computeFixedPointError(referenceBits);
    var res = new tcuTexCompareVerifier.CmpResultSet();

    switch (compareMode) {
        case tcuTexture.CompareMode.COMPAREMODE_LESS:
            res.isTrue = cmpReference - err < cmpValue;
            res.isFalse = cmpReference + err >= cmpValue;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_LESS_OR_EQUAL:
            res.isTrue = cmpReference - err <= cmpValue;
            res.isFalse = cmpReference + err > cmpValue;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_GREATER:
            res.isTrue = cmpReference + err > cmpValue;
            res.isFalse = cmpReference - err <= cmpValue;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_GREATER_OR_EQUAL:
            res.isTrue = cmpReference + err >= cmpValue;
            res.isFalse = cmpReference - err < cmpValue;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_EQUAL:
            res.isTrue = deMath.deInRange32(cmpValue, cmpReference - err, cmpReference + err);
            res.isFalse = err != 0 || cmpValue != cmpReference;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_NOT_EQUAL:
            res.isTrue = err != 0 || cmpValue != cmpReference;
            res.isFalse = deMath.deInRange32(cmpValue, cmpReference - err, cmpReference + err);
            break;

        case tcuTexture.CompareMode.COMPAREMODE_ALWAYS:
            res.isTrue = true;
            break;

        case tcuTexture.CompareMode.COMPAREMODE_NEVER:
            res.isFalse = true;
            break;

        default:
            throw new Error('Invalid compare mode:' + compareMode);
    }

    assertMsgOptions(res.isTrue || res.isFalse, 'Both tests failed!', false, true);
    return res;
};

/**
 * @param {tcuTexture.TextureFormat} format
 * @return {boolean}
 */
tcuTexCompareVerifier.isFixedPointDepthTextureFormat = function(format) {
    var channelClass = tcuTexture.getTextureChannelClass(format.type);

    if (format.order == tcuTexture.ChannelOrder.D) {
        // depth internal formats cannot be non-normalized integers
        return channelClass != tcuTexture.TextureChannelClass.FLOATING_POINT;
    } else if (format.order == tcuTexture.ChannelOrder.DS) {
        // combined formats have no single channel class, detect format manually
        switch (format.type) {
            case tcuTexture.ChannelType.FLOAT_UNSIGNED_INT_24_8_REV: return false;
            case tcuTexture.ChannelType.UNSIGNED_INT_24_8: return true;

            default:
                throw new Error('Invalid texture format: ' + format);
        }
    }

    return false;
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths
 * @param {Array<number>} fBounds
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isLinearCompareValid = function(compareMode, prec, depths, fBounds, cmpReference, result, isFixedPointDepth) {
    assertMsgOptions(fBounds[0] >= 0 && fBounds[0] <= fBounds[1] && fBounds[1] <= 1, 'Invalid fBounds', false, true);

    var d0 = depths[0];
    var d1 = depths[1];

    var cmp0 = tcuTexCompareVerifier.execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp1 = tcuTexCompareVerifier.execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp = [cmp0, cmp1];

    var isTrue = getMask(cmp, function(x) {return x.isTrue;});
    var isFalse = getMask(cmp, function(x) {return x.isFalse;});

    var f0 = fBounds[0];
    var f1 = fBounds[1];

    var pcfErr = tcuTexVerifierUtil.computeFixedPointError(prec.pcfBits);
    var resErr = tcuTexVerifierUtil.computeFixedPointError(prec.resultBits);
    var totalErr = pcfErr + resErr;

    for (var comb = 0; comb < 4; comb++) {
        if (((comb & isTrue) | (~comb & isFalse )) != 3)
            continue;

        var cmp0True = ((comb >> 0) & 1) != 0;
        var cmp1True = ((comb >> 1) & 1) != 0;

        var ref0 = cmp0True ? 1 : 0;
        var ref1 = cmp1True ? 1 : 0;

        var v0 = ref0 * (1 - f0) + ref1 * f0;
        var v1 = ref0 * (1 - f1) + ref1 * f1;
        var minV = Math.min(v0, v1);
        var maxV = Math.max(v0, v1);
        var minR = minV - totalErr;
        var maxR = maxV + totalErr;

        if (deMath.deInRange32(result, minR, maxR))
            return true;
    }
    return false;
};

/**
 * @param {number} val
 * @param {number} offset
 * @return {Array<boolean>}
 */
tcuTexCompareVerifier.extractBVec4 = function(val, offset) {
    return [
        ((val >> (offset + 0)) & 1) != 0,
        ((val >> (offset + 1)) & 1) != 0,
        ((val >> (offset + 2)) & 1) != 0,
        ((val >> (offset + 3)) & 1) != 0];
};

/**
 * Values are in order (0,0), (1,0), (0,1), (1,1)
 * @param {Array<number>} values
 * @param {number} x
 * @param {number} y
 * @return {number}
 */
tcuTexCompareVerifier.bilinearInterpolate = function(values, x, y) {
    var v00 = values[0];
    var v10 = values[1];
    var v01 = values[2];
    var v11 = values[3];
    var res = v00 * (1 - x) * (1 - y) + v10 * x * (1 - y) + v01 * (1 - x) * y + v11 * x * y;
    return res;
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths vec4
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isBilinearAnyCompareValid = function(compareMode,
                                    prec,
                                    depths,
                                    cmpReference,
                                    result,
                                    isFixedPointDepth) {
    assertMsgOptions(prec.pcfBits === 0, 'PCF bits must be 0', false, true);

    var d0 = depths[0];
    var d1 = depths[1];
    var d2 = depths[2];
    var d3 = depths[3];

    var cmp0 = tcuTexCompareVerifier.execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp1 = tcuTexCompareVerifier.execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp2 = tcuTexCompareVerifier.execCompare(compareMode, d2, cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp3 = tcuTexCompareVerifier.execCompare(compareMode, d3, cmpReference, prec.referenceBits, isFixedPointDepth);

    var canBeTrue = cmp0.isTrue || cmp1.isTrue || cmp2.isTrue || cmp3.isTrue;
    var canBeFalse = cmp0.isFalse || cmp1.isFalse || cmp2.isFalse || cmp3.isFalse;

    var resErr = tcuTexVerifierUtil.computeFixedPointError(prec.resultBits);

    var minBound = canBeFalse ? 0 : 1;
    var maxBound = canBeTrue ? 1 : 0;

    return deMath.deInRange32(result, minBound - resErr, maxBound + resErr);
};

/**
 * @param {Array<tcuTexCompareVerifier.CmpResultSet>} arr
 * @param {function(tcuTexCompareVerifier.CmpResultSet): boolean} getValue
 * @return {number}
 */
var getMask = function(arr, getValue) {
    var mask = 0;
    for (var i = 0; i < arr.length; i++) {
        var val = getValue(arr[i]);
        if (val)
            mask |= 1 << i;
    }
    return mask;
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths vec4
 * @param {Array<number>} xBounds vec2
 * @param {Array<number>} yBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isBilinearPCFCompareValid = function(compareMode,
                                    prec,
                                    depths,
                                    xBounds,
                                    yBounds,
                                    cmpReference,
                                    result,
                                    isFixedPointDepth) {
    assertMsgOptions(0.0 <= xBounds[0] && xBounds[0] <= xBounds[1] && xBounds[1] <= 1.0, 'x coordinate out of bounds', false, true);
    assertMsgOptions(0.0 <= yBounds[0] && yBounds[0] <= yBounds[1] && yBounds[1] <= 1.0, 'y coordinate out of bounds', false, true);
    assertMsgOptions(prec.pcfBits > 0, 'PCF bits must be > 0', false, true);

    var d0 = depths[0];
    var d1 = depths[1];
    var d2 = depths[2];
    var d3 = depths[3];

    /** @type {Array<tcuTexCompareVerifier.CmpResultSet>} */ var cmp = [];
    cmp[0] = tcuTexCompareVerifier.execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    cmp[1] = tcuTexCompareVerifier.execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);
    cmp[2] = tcuTexCompareVerifier.execCompare(compareMode, d2, cmpReference, prec.referenceBits, isFixedPointDepth);
    cmp[3] = tcuTexCompareVerifier.execCompare(compareMode, d3, cmpReference, prec.referenceBits, isFixedPointDepth);

    var isTrue = getMask(cmp, function(x) {return x.isTrue});
    var isFalse = getMask(cmp, function(x) {return x.isFalse});

    // Interpolation parameters
    var x0 = xBounds[0];
    var x1 = xBounds[1];
    var y0 = yBounds[0];
    var y1 = yBounds[1];

    // Error parameters
    var pcfErr = tcuTexVerifierUtil.computeFixedPointError(prec.pcfBits);
    var resErr = tcuTexVerifierUtil.computeFixedPointError(prec.resultBits);
    var totalErr = pcfErr + resErr;

    // Iterate over all valid combinations.
    // \note It is not enough to compute minmax over all possible result sets, as ranges may
    //       not necessarily overlap, i.e. there are gaps between valid ranges.
    for (var comb = 0; comb < (1 << 4); comb++) {
        // Filter out invalid combinations:
        //  1) True bit is set in comb but not in isTrue => sample can not be true
        //  2) True bit is NOT set in comb and not in isFalse => sample can not be false
        if (((comb & isTrue) | (~comb & isFalse)) != (1 << 4) - 1)
            continue;

        var cmpTrue = tcuTexCompareVerifier.extractBVec4(comb, 0);
        var refVal = tcuTextureUtil.select([1, 1, 1, 1], [0, 0, 0, 0], cmpTrue);

        var v0 = tcuTexCompareVerifier.bilinearInterpolate(refVal, x0, y0);
        var v1 = tcuTexCompareVerifier.bilinearInterpolate(refVal, x1, y0);
        var v2 = tcuTexCompareVerifier.bilinearInterpolate(refVal, x0, y1);
        var v3 = tcuTexCompareVerifier.bilinearInterpolate(refVal, x1, y1);
        var minV = Math.min(v0, v1, v2, v3);
        var maxV = Math.max(v0, v1, v2, v3);
        var minR = minV - totalErr;
        var maxR = maxV + totalErr;

        if (deMath.deInRange32(result, minR, maxR))
            return true;
    }

    return false;
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths vec4
 * @param {Array<number>} xBounds vec2
 * @param {Array<number>} yBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isBilinearCompareValid = function(compareMode,
                                    prec,
                                    depths,
                                    xBounds,
                                    yBounds,
                                    cmpReference,
                                    result,
                                    isFixedPointDepth) {
    if (prec.pcfBits > 0)
        return tcuTexCompareVerifier.isBilinearPCFCompareValid(compareMode, prec, depths, xBounds, yBounds, cmpReference, result, isFixedPointDepth);
    else
        return tcuTexCompareVerifier.isBilinearAnyCompareValid(compareMode, prec, depths, cmpReference, result, isFixedPointDepth);
};
/**
 * @param {tcuTexture.ConstPixelBufferAccess} level
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isLinearCompareResultValid = function(level,
                                       sampler,
                                       prec,
                                       coord,
                                       coordZ,
                                       cmpReference,
                                       result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(level.getFormat());
    var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]);

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    var minI = Math.floor(uBounds[0] - 0.5);
    var maxI = Math.floor(uBounds[1] - 0.5);
    var minJ = Math.floor(vBounds[0] - 0.5);
    var maxJ = Math.floor(vBounds[1] - 0.5);

    var w = level.getWidth();
    var h = level.getHeight();

    // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode.

    for (var j = minJ; j <= maxJ; j++) {
        for (var i = minI; i <= maxI; i++) {
            // Wrapped coordinates
            var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i, w);
            var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i + 1, w);
            var y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j, h);
            var y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j + 1, h);

            // Bounds for filtering factors
            var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1);
            var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1);
            var minB = deMath.clamp((vBounds[0] - 0.5) - j, 0, 1);
            var maxB = deMath.clamp((vBounds[1] - 0.5) - j, 0, 1);

            var depths = [
                level.getPixDepth(x0, y0, coordZ),
                level.getPixDepth(x1, y0, coordZ),
                level.getPixDepth(x0, y1, coordZ),
                level.getPixDepth(x1, y1, coordZ)
                ];

            if (tcuTexCompareVerifier.isBilinearCompareValid(sampler.compare, prec, depths, [minA, maxA], [minB, maxB], cmpReference, result, isFixedPointDepth))
                return true;
        }
    }

    return false;
};

/**
 * @param {tcuTexCompareVerifier.CmpResultSet} resultSet
 * @param {number} result
 * @param {number} resultBits
 */
tcuTexCompareVerifier.isResultInSet = function(resultSet, result, resultBits) {
    var err = tcuTexVerifierUtil.computeFixedPointError(resultBits);
    var minR = result - err;
    var maxR = result + err;

    return (resultSet.isTrue && deMath.deInRange32(1, minR, maxR)) ||
           (resultSet.isFalse && deMath.deInRange32(0, minR, maxR));
};

/**
 * @param {tcuTexture.ConstPixelBufferAccess} level
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isNearestCompareResultValid = function(level,
                                       sampler,
                                       prec,
                                       coord,
                                       coordZ,
                                       cmpReference,
                                       result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(level.getFormat());
    var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]);

    // Integer coordinates - without wrap mode
    var minI = Math.floor(uBounds[0]);
    var maxI = Math.floor(uBounds[1]);
    var minJ = Math.floor(vBounds[0]);
    var maxJ = Math.floor(vBounds[1]);

    for (var j = minJ; j <= maxJ; j++) {
        for (var i = minI; i <= maxI; i++) {
            var x = tcuTexVerifierUtil.wrap(sampler.wrapS, i, level.getWidth());
            var y = tcuTexVerifierUtil.wrap(sampler.wrapT, j, level.getHeight());
            var depth = level.getPixDepth(x, y, coordZ);
            var resSet = tcuTexCompareVerifier.execCompare(sampler.compare, depth, cmpReference, prec.referenceBits, isFixedPointDepth);

            if (tcuTexCompareVerifier.isResultInSet(resSet, result, prec.resultBits))
                return true;
        }
    }

    return false;
};

/**
 * @param {tcuTexture.ConstPixelBufferAccess} level
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexture.FilterMode} filterMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isLevelCompareResultValid = function(level,
                                       sampler,
                                       filterMode,
                                       prec,
                                       coord,
                                       coordZ,
                                       cmpReference,
                                       result) {
    if (filterMode == tcuTexture.FilterMode.LINEAR)
        return tcuTexCompareVerifier.isLinearCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
    else
        return tcuTexCompareVerifier.isNearestCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths0 vec4
 * @param {Array<number>} depths1 vec4
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isTrilinearAnyCompareValid = function(compareMode,
                                     prec,
                                     depths0,
                                     depths1,
                                     cmpReference,
                                     result,
                                     isFixedPointDepth) {
    assertMsgOptions(prec.pcfBits === 0, 'PCF bits must be 0', false, true);

    var cmp00 = tcuTexCompareVerifier.execCompare(compareMode, depths0[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp01 = tcuTexCompareVerifier.execCompare(compareMode, depths0[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp02 = tcuTexCompareVerifier.execCompare(compareMode, depths0[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp03 = tcuTexCompareVerifier.execCompare(compareMode, depths0[3], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp10 = tcuTexCompareVerifier.execCompare(compareMode, depths1[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp11 = tcuTexCompareVerifier.execCompare(compareMode, depths1[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp12 = tcuTexCompareVerifier.execCompare(compareMode, depths1[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    var cmp13 = tcuTexCompareVerifier.execCompare(compareMode, depths1[3], cmpReference, prec.referenceBits, isFixedPointDepth);

    var canBeTrue = cmp00.isTrue ||
                                      cmp01.isTrue ||
                                      cmp02.isTrue ||
                                      cmp03.isTrue ||
                                      cmp10.isTrue ||
                                      cmp11.isTrue ||
                                      cmp12.isTrue ||
                                      cmp13.isTrue;
    var canBeFalse = cmp00.isFalse ||
                                      cmp01.isFalse ||
                                      cmp02.isFalse ||
                                      cmp03.isFalse ||
                                      cmp10.isFalse ||
                                      cmp11.isFalse ||
                                      cmp12.isFalse ||
                                      cmp13.isFalse;

    var resErr = tcuTexVerifierUtil.computeFixedPointError(prec.resultBits);

    var minBound = canBeFalse ? 0 : 1;
    var maxBound = canBeTrue ? 1 : 0;

    return deMath.deInRange32(result, minBound - resErr, maxBound + resErr);
};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths0 vec4
 * @param {Array<number>} depths1 vec4
 * @param {Array<number>} xBounds0
 * @param {Array<number>} yBounds0
 * @param {Array<number>} xBounds1
 * @param {Array<number>} yBounds1
 * @param {Array<number>} fBounds
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isTrilinearPCFCompareValid = function(compareMode,
                                     prec,
                                     depths0,
                                     depths1,
                                     xBounds0,
                                     yBounds0,
                                     xBounds1,
                                     yBounds1,
                                     fBounds,
                                     cmpReference,
                                     result,
                                     isFixedPointDepth) {
    assertMsgOptions(0.0 <= xBounds0[0] && xBounds0[0] <= xBounds0[1] && xBounds0[1] <= 1.0, 'x0 coordinate out of bounds', false, true);
    assertMsgOptions(0.0 <= yBounds0[0] && yBounds0[0] <= yBounds0[1] && yBounds0[1] <= 1.0, 'y0 coordinate out of bounds', false, true);
    assertMsgOptions(0.0 <= xBounds1[0] && xBounds1[0] <= xBounds1[1] && xBounds1[1] <= 1.0, 'x1 coordinate out of bounds', false, true);
    assertMsgOptions(0.0 <= yBounds1[0] && yBounds1[0] <= yBounds1[1] && yBounds1[1] <= 1.0, 'y1 coordinate out of bounds', false, true);
    assertMsgOptions(0.0 <= fBounds[0] && fBounds[0] <= fBounds[1] && fBounds[1] <= 1.0, 'linear factor out of bounds', false, true);
    assertMsgOptions(prec.pcfBits > 0, 'PCF bits must be > 0', false, true);

    /** @type {Array<tcuTexCompareVerifier.CmpResultSet>} */ var cmp = [];
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths0[0], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths0[1], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths0[2], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths0[3], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths1[0], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths1[1], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths1[2], cmpReference, prec.referenceBits, isFixedPointDepth));
    cmp.push(tcuTexCompareVerifier.execCompare(compareMode, depths1[3], cmpReference, prec.referenceBits, isFixedPointDepth));

    var isTrue = getMask(cmp, function(x) {return x.isTrue});
    var isFalse = getMask(cmp, function(x) {return x.isFalse});

    // Error parameters
    var pcfErr = tcuTexVerifierUtil.computeFixedPointError(prec.pcfBits);
    var resErr = tcuTexVerifierUtil.computeFixedPointError(prec.resultBits);
    var totalErr = pcfErr + resErr;

    // Iterate over all valid combinations.
    for (var comb = 0; comb < (1 << 8); comb++) {
        // Filter out invalid combinations.
        if (((comb & isTrue) | (~comb & isFalse)) != (1 << 8) - 1)
            continue;

        var cmpTrue0 = tcuTexCompareVerifier.extractBVec4(comb, 0);
        var cmpTrue1 = tcuTexCompareVerifier.extractBVec4(comb, 4);
        var refVal0 = tcuTextureUtil.select([1, 1, 1, 1], [0, 0, 0, 0], cmpTrue0);
        var refVal1 = tcuTextureUtil.select([1, 1, 1, 1], [0, 0, 0, 0], cmpTrue1);

        // Bilinear interpolation within levels.
        var v00 = tcuTexCompareVerifier.bilinearInterpolate(refVal0, xBounds0[0], yBounds0[0]);
        var v01 = tcuTexCompareVerifier.bilinearInterpolate(refVal0, xBounds0[1], yBounds0[0]);
        var v02 = tcuTexCompareVerifier.bilinearInterpolate(refVal0, xBounds0[0], yBounds0[1]);
        var v03 = tcuTexCompareVerifier.bilinearInterpolate(refVal0, xBounds0[1], yBounds0[1]);
        var minV0 = Math.min(v00, v01, v02, v03);
        var maxV0 = Math.max(v00, v01, v02, v03);

        var v10 = tcuTexCompareVerifier.bilinearInterpolate(refVal1, xBounds1[0], yBounds1[0]);
        var v11 = tcuTexCompareVerifier.bilinearInterpolate(refVal1, xBounds1[1], yBounds1[0]);
        var v12 = tcuTexCompareVerifier.bilinearInterpolate(refVal1, xBounds1[0], yBounds1[1]);
        var v13 = tcuTexCompareVerifier.bilinearInterpolate(refVal1, xBounds1[1], yBounds1[1]);
        var minV1 = Math.min(v10, v11, v12, v13);
        var maxV1 = Math.max(v10, v11, v12, v13);

        // Compute min-max bounds by filtering between minimum bounds and maximum bounds between levels.
        // HW can end up choosing pretty much any of samples between levels, and thus interpolating
        // between minimums should yield lower bound for range, and same for upper bound.
        // \todo [2013-07-17 pyry] This seems separable? Can this be optimized? At least ranges could be pre-computed and later combined.
        var minF0 = minV0 * (1 - fBounds[0]) + minV1 * fBounds[0];
        var minF1 = minV0 * (1 - fBounds[1]) + minV1 * fBounds[1];
        var maxF0 = maxV0 * (1 - fBounds[0]) + maxV1 * fBounds[0];
        var maxF1 = maxV0 * (1 - fBounds[1]) + maxV1 * fBounds[1];

        var minF = Math.min(minF0, minF1);
        var maxF = Math.max(maxF0, maxF1);

        var minR = minF - totalErr;
        var maxR = maxF + totalErr;

        if (deMath.deInRange32(result, minR, maxR))
            return true;
    }

    return false;

};

/**
 * @param {tcuTexture.CompareMode} compareMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} depths0 vec4
 * @param {Array<number>} depths1 vec4
 * @param {Array<number>} xBounds0
 * @param {Array<number>} yBounds0
 * @param {Array<number>} xBounds1
 * @param {Array<number>} yBounds1
 * @param {Array<number>} fBounds
 * @param {number} cmpReference
 * @param {number} result
 * @param {boolean} isFixedPointDepth
 * @return {boolean}
 */
tcuTexCompareVerifier.isTrilinearCompareValid = function(compareMode,
                                     prec,
                                     depths0,
                                     depths1,
                                     xBounds0,
                                     yBounds0,
                                     xBounds1,
                                     yBounds1,
                                     fBounds,
                                     cmpReference,
                                     result,
                                     isFixedPointDepth) {
    if (prec.pcfBits > 0)
        return tcuTexCompareVerifier.isTrilinearPCFCompareValid(compareMode, prec, depths0, depths1, xBounds0, yBounds0, xBounds1, yBounds1, fBounds, cmpReference, result, isFixedPointDepth);
    else
        return tcuTexCompareVerifier.isTrilinearAnyCompareValid(compareMode, prec, depths0, depths1, cmpReference, result, isFixedPointDepth);
};

/**
 * @param {tcuTexture.ConstPixelBufferAccess} level0
 * @param {tcuTexture.ConstPixelBufferAccess} level1
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {Array<number>} fBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isLinearMipmapLinearCompareResultValid = function(level0,
                                              level1,
                                              sampler,
                                              prec,
                                              coord,
                                              coordZ,
                                              fBounds,
                                              cmpReference,
                                              result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(level0.getFormat());

    // \todo [2013-07-04 pyry] This is strictly not correct as coordinates between levels should be dependent.
    //                         Right now this allows pairing any two valid bilinear quads.

    var w0 = level0.getWidth();
    var w1 = level1.getWidth();
    var h0 = level0.getHeight();
    var h1 = level1.getHeight();

    var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]);
    var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]);

    // Integer coordinates - without wrap mode
    var minI0 = Math.floor(uBounds0[0] - 0.5);
    var maxI0 = Math.floor(uBounds0[1] - 0.5);
    var minI1 = Math.floor(uBounds1[0] - 0.5);
    var maxI1 = Math.floor(uBounds1[1] - 0.5);
    var minJ0 = Math.floor(vBounds0[0] - 0.5);
    var maxJ0 = Math.floor(vBounds0[1] - 0.5);
    var minJ1 = Math.floor(vBounds1[0] - 0.5);
    var maxJ1 = Math.floor(vBounds1[1] - 0.5);

    for (var j0 = minJ0; j0 <= maxJ0; j0++) {
        for (var i0 = minI0; i0 <= maxI0; i0++) {
            var minA0 = deMath.clamp((uBounds0[0] - 0.5) - i0, 0, 1);
            var maxA0 = deMath.clamp((uBounds0[1] - 0.5) - i0, 0, 1);
            var minB0 = deMath.clamp((vBounds0[0] - 0.5) - j0, 0, 1);
            var maxB0 = deMath.clamp((vBounds0[1] - 0.5) - j0, 0, 1);
            var depths0 = [];

            var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0);
            var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0 + 1, w0);
            var y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0);
            var y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0 + 1, h0);

            depths0[0] = level0.getPixDepth(x0, y0, coordZ);
            depths0[1] = level0.getPixDepth(x1, y0, coordZ);
            depths0[2] = level0.getPixDepth(x0, y1, coordZ);
            depths0[3] = level0.getPixDepth(x1, y1, coordZ);

            for (var j1 = minJ1; j1 <= maxJ1; j1++) {
                for (var i1 = minI1; i1 <= maxI1; i1++) {
                    var minA1 = deMath.clamp((uBounds1[0] - 0.5) - i1, 0, 1);
                    var maxA1 = deMath.clamp((uBounds1[1] - 0.5) - i1, 0, 1);
                    var minB1 = deMath.clamp((vBounds1[0] - 0.5) - j1, 0, 1);
                    var maxB1 = deMath.clamp((vBounds1[1] - 0.5) - j1, 0, 1);
                    var depths1 = [];

                    x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1);
                    x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1 + 1, w1);
                    y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1);
                    y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1 + 1, h1);

                    depths1[0] = level1.getPixDepth(x0, y0, coordZ);
                    depths1[1] = level1.getPixDepth(x1, y0, coordZ);
                    depths1[2] = level1.getPixDepth(x0, y1, coordZ);
                    depths1[3] = level1.getPixDepth(x1, y1, coordZ);

                    if (tcuTexCompareVerifier.isTrilinearCompareValid(sampler.compare, prec, depths0, depths1,
                                                [minA0, maxA0], [minB0, maxB0],
                                                [minA1, maxA1], [minB1, maxB1],
                                                fBounds, cmpReference, result, isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
};

/**
 * @param {tcuTexture.ConstPixelBufferAccess} level0
 * @param {tcuTexture.ConstPixelBufferAccess} level1
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {Array<number>} fBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isNearestMipmapLinearCompareResultValid = function(level0,
                                              level1,
                                              sampler,
                                              prec,
                                              coord,
                                              coordZ,
                                              fBounds,
                                              cmpReference,
                                              result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(level0.getFormat());

    var w0 = level0.getWidth();
    var w1 = level1.getWidth();
    var h0 = level0.getHeight();
    var h1 = level1.getHeight();

    var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]);
    var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]);
    var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]);

    var minI0 = Math.floor(uBounds0[0]);
    var maxI0 = Math.floor(uBounds0[1]);
    var minI1 = Math.floor(uBounds1[0]);
    var maxI1 = Math.floor(uBounds1[1]);
    var minJ0 = Math.floor(vBounds0[0]);
    var maxJ0 = Math.floor(vBounds0[1]);
    var minJ1 = Math.floor(vBounds1[0]);
    var maxJ1 = Math.floor(vBounds1[1]);

    for (var j0 = minJ0; j0 <= maxJ0; j0++) {
        for (var i0 = minI0; i0 <= maxI0; i0++) {
            var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0);
            var y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0);

            // Derivated from C++ dEQP function lookupDepth()
            // Since x0 and y0 are wrapped, here lookupDepth() returns the same result as getPixDepth()
            assertMsgOptions(deMath.deInBounds32(x0, 0, level0.getWidth()) && deMath.deInBounds32(y0, 0, level0.getHeight()) && deMath.deInBounds32(coordZ, 0, level0.getDepth()), 'x0, y0 or coordZ out of bound.', false, true);
            var depth0 = level0.getPixDepth(x0, y0, coordZ);

            for (var j1 = minJ1; j1 <= maxJ1; j1++) {
                for (var i1 = minI1; i1 <= maxI1; i1++) {
                    var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1);
                    var y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1);

                    // Derivated from C++ dEQP function lookupDepth()
                    // Since x1 and y1 are wrapped, here lookupDepth() returns the same result as getPixDepth()
                    assertMsgOptions(deMath.deInBounds32(x1, 0, level1.getWidth()) && deMath.deInBounds32(y1, 0, level1.getHeight()), 'x1 or y1 out of bound.', false, true);
                    var depth1 = level1.getPixDepth(x1, y1, coordZ);

                    if (tcuTexCompareVerifier.isLinearCompareValid(sampler.compare, prec, [depth0, depth1], fBounds, cmpReference, result, isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
};

/**
 * @param {tcuTexture.ConstPixelBufferAccess} level0
 * @param {tcuTexture.ConstPixelBufferAccess} level1
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexture.FilterMode} levelFilter
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {number} coordZ
 * @param {Array<number>} fBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isMipmapLinearCompareResultValid = function(level0,
                                              level1,
                                              sampler,
                                              levelFilter,
                                              prec,
                                              coord,
                                              coordZ,
                                              fBounds,
                                              cmpReference,
                                              result) {
    if (levelFilter == tcuTexture.FilterMode.LINEAR)
        return tcuTexCompareVerifier.isLinearMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds, cmpReference, result);
    else
        return tcuTexCompareVerifier.isNearestMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds, cmpReference, result);
};

/**
 * @param {tcuTexture.Texture2DView} texture
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {Array<number>} lodBounds vec2 level-of-detail bounds
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isTexCompareResultValid2D = function(texture, sampler, prec, coord, lodBounds, cmpReference, result) {
    var minLod = lodBounds[0];
    var maxLod = lodBounds[1];
    var canBeMagnified = minLod <= sampler.lodThreshold;
    var canBeMinified = maxLod > sampler.lodThreshold;

    if (canBeMagnified) {
        if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, coord, 0, cmpReference, result))
            return true;
    }

    if (canBeMinified) {
        var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter);
        var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter);
        var minTexLevel = 0;
        var maxTexLevel = texture.getNumLevels() - 1;

        assertMsgOptions(minTexLevel < maxTexLevel, 'Invalid texture levels.', false, true);

        if (isLinearMipmap) {
            var minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1);
            var maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1);

            assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

            for (var level = minLevel; level <= maxLevel; level++) {
                var minF = deMath.clamp(minLod - level, 0, 1);
                var maxF = deMath.clamp(maxLod - level, 0, 1);

                if (tcuTexCompareVerifier.isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, 0, [minF, maxF], cmpReference, result))
                    return true;
            }
        } else if (isNearestMipmap) {
            // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made
            //       decision to allow floor(lod + 0.5) as well.
            var minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel);
            var maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel);

            assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

            for (var level = minLevel; level <= maxLevel; level++) {
                if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(level), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, 0, cmpReference, result))
                    return true;
            }
        } else {
            if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec, coord, 0, cmpReference, result))
                return true;
        }
    }

    return false;
};

/**
 * @param {tcuTexture.TextureCubeView} texture
 * @param {number} baseLevelNdx
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {tcuTexture.CubeFaceCoords} coords
 * @param {Array<number>} fBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isSeamplessLinearMipmapLinearCompareResultValid = function(texture,
                                                             baseLevelNdx,
                                                             sampler,
                                                             prec,
                                                             coords,
                                                             fBounds,
                                                             cmpReference,
                                                             result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(texture.getLevelFace(baseLevelNdx, tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X).getFormat());
    var size0 = texture.getLevelFace(baseLevelNdx, coords.face).getWidth();
    var size1 = texture.getLevelFace(baseLevelNdx + 1, coords.face).getWidth();

    var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.s, prec.coordBits[0], prec.uvwBits[0]);
    var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.s, prec.coordBits[0], prec.uvwBits[0]);
    var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.t, prec.coordBits[1], prec.uvwBits[1]);
    var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.t, prec.coordBits[1], prec.uvwBits[1]);

    // Integer coordinates - without wrap mode
    var minI0 = Math.floor(uBounds0[0] - 0.5);
    var maxI0 = Math.floor(uBounds0[1] - 0.5);
    var minI1 = Math.floor(uBounds1[0] - 0.5);
    var maxI1 = Math.floor(uBounds1[1] - 0.5);
    var minJ0 = Math.floor(vBounds0[0] - 0.5);
    var maxJ0 = Math.floor(vBounds0[1] - 0.5);
    var minJ1 = Math.floor(vBounds1[0] - 0.5);
    var maxJ1 = Math.floor(vBounds1[1] - 0.5);

    /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces0 = [];
    /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces1 = [];

    for (var key in tcuTexture.CubeFace) {
        var face = tcuTexture.CubeFace[key];
        faces0[face] = texture.getLevelFace(baseLevelNdx, face);
        faces1[face] = texture.getLevelFace(baseLevelNdx + 1, face);
    }

    for (var j0 = minJ0; j0 <= maxJ0; j0++) {
        for (var i0 = minI0; i0 <= maxI0; i0++) {
            var minA0 = deMath.clamp((uBounds0[0] - 0.5) - i0, 0, 1);
            var maxA0 = deMath.clamp((uBounds0[1] - 0.5) - i0, 0, 1);
            var minB0 = deMath.clamp((vBounds0[0] - 0.5) - j0, 0, 1);
            var maxB0 = deMath.clamp((vBounds0[1] - 0.5) - j0, 0, 1);
            var depths0 = [];

            var c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 0, j0 + 0]), size0);
            var c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 1, j0 + 0]), size0);
            var c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 0, j0 + 1]), size0);
            var c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 1, j0 + 1]), size0);

            // If any of samples is out of both edges, implementations can do pretty much anything according to spec.
            // \todo [2013-07-08 pyry] Test the special case where all corner pixels have exactly the same color.
            if (c00 == null || c01 == null || c10 == null || c11 == null)
                return true;

            depths0[0] = faces0[c00.face].getPixDepth(c00.s, c00.t);
            depths0[1] = faces0[c10.face].getPixDepth(c10.s, c10.t);
            depths0[2] = faces0[c01.face].getPixDepth(c01.s, c01.t);
            depths0[3] = faces0[c11.face].getPixDepth(c11.s, c11.t);

            for (var j1 = minJ1; j1 <= maxJ1; j1++) {
                for (var i1 = minI1; i1 <= maxI1; i1++) {
                    var minA1 = deMath.clamp((uBounds1[0] - 0.5) - i1, 0, 1);
                    var maxA1 = deMath.clamp((uBounds1[1] - 0.5) - i1, 0, 1);
                    var minB1 = deMath.clamp((vBounds1[0] - 0.5) - j1, 0, 1);
                    var maxB1 = deMath.clamp((vBounds1[1] - 0.5) - j1, 0, 1);
                    var depths1 = [];

                    c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 0, j1 + 0]), size1);
                    c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 1, j1 + 0]), size1);
                    c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 0, j1 + 1]), size1);
                    c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 1, j1 + 1]), size1);

                    if (c00 == null || c01 == null || c10 == null || c11 == null)
                        return true;

                    depths1[0] = faces1[c00.face].getPixDepth(c00.s, c00.t);
                    depths1[1] = faces1[c10.face].getPixDepth(c10.s, c10.t);
                    depths1[2] = faces1[c01.face].getPixDepth(c01.s, c01.t);
                    depths1[3] = faces1[c11.face].getPixDepth(c11.s, c11.t);

                    if (tcuTexCompareVerifier.isTrilinearCompareValid(sampler.compare, prec, depths0, depths1,
                                                [minA0, maxA0], [minB0, maxB0],
                                                [minA1, maxA1], [minB1, maxB1],
                                                fBounds, cmpReference, result, isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
};

/**
 * @param {tcuTexture.TextureCubeView} texture
 * @param {number} levelNdx
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {tcuTexture.CubeFaceCoords} coords
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */

tcuTexCompareVerifier.isSeamlessLinearCompareResultValid = function(texture,
                                                levelNdx,
                                                sampler,
                                                prec,
                                                coords,
                                                cmpReference,
                                                result) {
    var isFixedPointDepth = tcuTexCompareVerifier.isFixedPointDepthTextureFormat(texture.getLevelFace(levelNdx, tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X).getFormat());
    var size = texture.getLevelFace(levelNdx, coords.face).getWidth();

    var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.s, prec.coordBits[0], prec.uvwBits[0]);
    var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.t, prec.coordBits[1], prec.uvwBits[1]);

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    var minI = Math.floor(uBounds[0] - 0.5);
    var maxI = Math.floor(uBounds[1] - 0.5);
    var minJ = Math.floor(vBounds[0] - 0.5);
    var maxJ = Math.floor(vBounds[1] - 0.5);

    // Face accesses
    /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces = [];

    for (var key in tcuTexture.CubeFace) {
        var face = tcuTexture.CubeFace[key];
        faces[face] = texture.getLevelFace(levelNdx, face);
    }

    for (var j = minJ; j <= maxJ; j++) {
        for (var i = minI; i <= maxI; i++) {
            var c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 0, j + 0]), size);
            var c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 1, j + 0]), size);
            var c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 0, j + 1]), size);
            var c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 1, j + 1]), size);

            // If any of samples is out of both edges, implementations can do pretty much anything according to spec.
            // \todo [2013-07-08 pyry] Test the special case where all corner pixels have exactly the same color.
            if (!c00 || !c01 || !c10 || !c11)
                return true;

            // Bounds for filtering factors
            var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1);
            var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1);
            var minB = deMath.clamp((vBounds[0] - 0.5) - j, 0, 1);
            var maxB = deMath.clamp((vBounds[1] - 0.5) - j, 0, 1);

            var depths = [];
            depths[0] = faces[c00.face].getPixDepth(c00.s, c00.t);
            depths[1] = faces[c10.face].getPixDepth(c10.s, c10.t);
            depths[2] = faces[c01.face].getPixDepth(c01.s, c01.t);
            depths[3] = faces[c11.face].getPixDepth(c11.s, c11.t);

            if (tcuTexCompareVerifier.isBilinearCompareValid(sampler.compare, prec, depths, [minA, maxA], [minB, maxB], cmpReference, result, isFixedPointDepth))
                return true;
        }
    }

    return false;
};

/**
 * @param {tcuTexture.TextureCubeView} texture
 * @param {number} levelNdx
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexture.FilterMode} filterMode
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {tcuTexture.CubeFaceCoords} coords
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isCubeLevelCompareResultValid = function(texture,
                                           levelNdx,
                                           sampler,
                                           filterMode,
                                           prec,
                                           coords,
                                           cmpReference,
                                           result) {
    if (filterMode == tcuTexture.FilterMode.LINEAR) {
        if (sampler.seamlessCubeMap)
            return tcuTexCompareVerifier.isSeamlessLinearCompareResultValid(texture, levelNdx, sampler, prec, coords, cmpReference, result);
        else
            return tcuTexCompareVerifier.isLinearCompareResultValid(texture.getLevelFace(levelNdx, coords.face), sampler, prec, [coords.s, coords.t], 0, cmpReference, result);
    } else
        return tcuTexCompareVerifier.isNearestCompareResultValid(texture.getLevelFace(levelNdx, coords.face), sampler, prec, [coords.s, coords.t], 0, cmpReference, result);
};

/**
 * @param {tcuTexture.TextureCubeView} texture
 * @param {number} baseLevelNdx
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexture.FilterMode} levelFilter
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {tcuTexture.CubeFaceCoords} coords
 * @param {Array<number>} fBounds vec2
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isCubeMipmapLinearCompareResultValid = function(texture,
                                                  baseLevelNdx,
                                                  sampler,
                                                  levelFilter,
                                                  prec,
                                                  coords,
                                                  fBounds,
                                                  cmpReference,
                                                  result) {
    if (levelFilter == tcuTexture.FilterMode.LINEAR) {
        if (sampler.seamlessCubeMap)
            return tcuTexCompareVerifier.isSeamplessLinearMipmapLinearCompareResultValid(texture, baseLevelNdx, sampler, prec, coords, fBounds, cmpReference, result);
        else
            return tcuTexCompareVerifier.isLinearMipmapLinearCompareResultValid(texture.getLevelFace(baseLevelNdx, coords.face),
                                                          texture.getLevelFace(baseLevelNdx + 1, coords.face),
                                                          sampler, prec, [coords.s, coords.t], 0, fBounds, cmpReference, result);
    } else
        return tcuTexCompareVerifier.isNearestMipmapLinearCompareResultValid(texture.getLevelFace(baseLevelNdx, coords.face),
                                                       texture.getLevelFace(baseLevelNdx + 1, coords.face),
                                                       sampler, prec, [coords.s, coords.t], 0, fBounds, cmpReference, result);
};

/**
 * @param {tcuTexture.TextureCubeView} texture
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec2 texture coordinates
 * @param {Array<number>} lodBounds vec2 level-of-detail bounds
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isTexCompareResultValidCube = function(texture, sampler, prec, coord, lodBounds, cmpReference, result) {
    /** @type {Array<tcuTexture.CubeFace>} */var possibleFaces = tcuTexVerifierUtil.getPossibleCubeFaces(coord, prec.coordBits);

    if (!possibleFaces)
        return true; // Result is undefined.

    for (var tryFaceNdx = 0; tryFaceNdx < possibleFaces.length; tryFaceNdx++) {
        var face = possibleFaces[tryFaceNdx];
        var faceCoords = new tcuTexture.CubeFaceCoords(face, tcuTexture.projectToFace(face, coord));
        var minLod = lodBounds[0];
        var maxLod = lodBounds[1];
        var canBeMagnified = minLod <= sampler.lodThreshold;
        var canBeMinified = maxLod > sampler.lodThreshold;

        if (canBeMagnified) {
            if (tcuTexCompareVerifier.isCubeLevelCompareResultValid(texture, 0, sampler, sampler.magFilter, prec, faceCoords, cmpReference, result))
                return true;
        }

        if (canBeMinified) {
            var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter);
            var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter);
            var minTexLevel = 0;
            var maxTexLevel = texture.getNumLevels() - 1;

            assertMsgOptions(minTexLevel < maxTexLevel, 'Invalid texture levels.', false, true);

            if (isLinearMipmap) {
                var minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1);
                var maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1);

                assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

                for (var level = minLevel; level <= maxLevel; level++) {
                    var minF = deMath.clamp(minLod - level, 0, 1);
                    var maxF = deMath.clamp(maxLod - level, 0, 1);

                    if (tcuTexCompareVerifier.isCubeMipmapLinearCompareResultValid(texture, level, sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, faceCoords, [minF, maxF], cmpReference, result))
                        return true;
                }
            } else if (isNearestMipmap) {
                // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made
                //       decision to allow floor(lod + 0.5) as well.
                var minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel);
                var maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel);

                assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

                for (var level = minLevel; level <= maxLevel; level++) {
                    if (tcuTexCompareVerifier.isCubeLevelCompareResultValid(texture, level, sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, faceCoords, cmpReference, result))
                        return true;
                }
            } else {
                if (tcuTexCompareVerifier.isCubeLevelCompareResultValid(texture, 0, sampler, sampler.minFilter, prec, faceCoords, cmpReference, result))
                    return true;
            }
        }
    }

    return false;
};

/**
 * @param {tcuTexture.Texture2DArrayView} texture
 * @param {tcuTexture.Sampler} sampler
 * @param {tcuTexCompareVerifier.TexComparePrecision} prec
 * @param {Array<number>} coord vec3 texture coordinates
 * @param {Array<number>} lodBounds vec2 level-of-detail bounds
 * @param {number} cmpReference
 * @param {number} result
 * @return {boolean}
 */
tcuTexCompareVerifier.isTexCompareResultValid2DArray = function(texture, sampler, prec, coord, lodBounds, cmpReference, result) {
    var depthErr = tcuTexVerifierUtil.computeFloatingPointError(coord[2], prec.coordBits[2]) + tcuTexVerifierUtil.computeFixedPointError(prec.uvwBits[2]);
    var minZ = coord[2] - depthErr;
    var maxZ = coord[2] + depthErr;
    var minLayer = deMath.clamp(Math.floor(minZ + 0.5), 0, texture.getNumLayers() - 1);
    var maxLayer = deMath.clamp(Math.floor(maxZ + 0.5), 0, texture.getNumLayers() - 1);

    for (var layer = minLayer; layer <= maxLayer; layer++) {
        var minLod = lodBounds[0];
        var maxLod = lodBounds[1];
        var canBeMagnified = minLod <= sampler.lodThreshold;
        var canBeMinified = maxLod > sampler.lodThreshold;

        if (canBeMagnified) {
            if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, deMath.swizzle(coord, [0, 1]), layer, cmpReference, result))
                return true;
        }

        if (canBeMinified) {
            var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter);
            var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter);
            var minTexLevel = 0;
            var maxTexLevel = texture.getNumLevels() - 1;

            assertMsgOptions(minTexLevel < maxTexLevel, 'Invalid texture levels.', false, true);

            if (isLinearMipmap) {
                var minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1);
                var maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1);

                assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

                for (var level = minLevel; level <= maxLevel; level++) {
                    var minF = deMath.clamp(minLod - level, 0, 1);
                    var maxF = deMath.clamp(maxLod - level, 0, 1);

                    if (tcuTexCompareVerifier.isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, deMath.swizzle(coord, [0, 1]), layer, [minF, maxF], cmpReference, result))
                        return true;
                }
            } else if (isNearestMipmap) {
                // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made
                //       decision to allow floor(lod + 0.5) as well.
                var minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel);
                var maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel);

                assertMsgOptions(minLevel <= maxLevel, 'Invalid texture levels.', false, true);

                for (var level = minLevel; level <= maxLevel; level++) {
                    if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(level), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, deMath.swizzle(coord, [0, 1]), layer, cmpReference, result))
                        return true;
                }
            } else {
                if (tcuTexCompareVerifier.isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec, deMath.swizzle(coord, [0, 1]), layer, cmpReference, result))
                    return true;
            }
        }
    }

    return false;
};

});