﻿<!--

/*
** Copyright (c) 2012-2016 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/

-->

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<link rel="stylesheet" href="../../resources/js-test-style.css"/>
<script src="../../js/js-test-pre.js"></script>
<script src="../../js/webgl-test-utils.js"></script>
<title>WebGL WEBGL_compressed_texture_s3tc_srgb Conformance Tests</title>
<style>
img {
 border: 1px solid black;
 margin-right: 1em;
}
.testimages {
}

.testimages br {
  clear: both;
}

.testimages > div {
  float: left;
  margin: 1em;
}
</style>
</head>
<body>
<div id="description"></div>
<canvas id="canvas" width="8" height="8" style="width: 8px; height: 8px;"></canvas>
<div id="console"></div>
<script>
"use strict";
description("This test verifies the functionality of the WEBGL_compressed_texture_s3tc_srgb extension, if it is available.");

debug("");

// This is the original image from webgl-compressed-texture-s3tc.html but
// scaled to 0x40..0xbf inclusive and alpha changed from 0x69 to 0x7f.
var img_4x4_rgba_raw = new Uint8Array([
    0xbf,0x40,0x40,0x7f,0x40,0xbf,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,
    0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,
    0xbf,0x40,0x40,0xff,0xbf,0x40,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,
    0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,
]);
var img_4x4_rgb_dxt1 = new Uint8Array([
    0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,
]);
var img_4x4_rgba_dxt1 = new Uint8Array([
    0xa8,0x4d,0x48,0xb2,0x13,0x10,0x15,0x00,
]);
var img_4x4_rgba_dxt3 = new Uint8Array([
    0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,
]);
var img_4x4_rgba_dxt5 = new Uint8Array([
    0xff,0x7f,0x01,0x00,0x00,0x00,0x00,0x00,0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,
]);
var img_8x8_rgba_raw = new Uint8Array([
    0xdf,0xa0,0xa0,0x7f,0x40,0xbf,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,0xbf,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,0xbf,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,
    0x40,0xbf,0x40,0x7f,0x40,0xbf,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0xbf,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,
    0xbf,0x40,0x40,0xff,0xbf,0x40,0x40,0xff,0xbf,0x40,0x40,0xff,0x40,0xbf,0x40,0xff,0xbf,0xbf,0x40,0xff,0xbf,0xbf,0x40,0xff,0xbf,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,
    0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,
    0x40,0xbf,0x40,0xff,0xbf,0x40,0xbf,0xff,0x40,0xbf,0x40,0xff,0xbf,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,
    0xbf,0x40,0xbf,0xff,0xbf,0x40,0xbf,0xff,0x40,0xbf,0x40,0xff,0xbf,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,
    0x40,0xbf,0x40,0x7f,0x40,0xbf,0x40,0xff,0x40,0xbf,0x40,0xff,0xbf,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,
    0xbf,0x40,0xbf,0x7f,0xbf,0x40,0xbf,0xff,0xbf,0x40,0xbf,0xff,0xbf,0x40,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0xbf,0xbf,0xff,0x40,0xbf,0xbf,0xff,
]);
var img_8x8_rgb_dxt1 = new Uint8Array([
    0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,0xe8,0xbd,0x17,0x42,0x44,0x45,0x40,0x55,0x17,0xba,0xe8,0x45,0x11,0x10,0x15,0x00,0xf7,0x45,0x17,0x42,0x11,0x10,0x15,0x00,
]);
var img_8x8_rgba_dxt1 = new Uint8Array([
    0xa8,0x4d,0x48,0xb2,0x13,0x10,0x15,0x00,0xe8,0xbd,0x17,0x42,0x44,0x45,0x40,0x55,0x17,0xba,0xe8,0x45,0x11,0x10,0x15,0x00,0xf7,0x45,0x17,0x42,0x11,0x10,0x15,0x00,
]);
var img_8x8_rgba_dxt3 = new Uint8Array([
    0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xe8,0xbd,0x17,0x42,0x44,0x45,0x40,0x55,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x17,0xba,0xe8,0x45,0x11,0x10,0x15,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xf7,0x45,0x17,0x42,0x11,0x10,0x15,0x00,
]);
var img_8x8_rgba_dxt5 = new Uint8Array([
    0xff,0x7f,0x01,0x00,0x00,0x00,0x00,0x00,0x08,0xba,0xe8,0x45,0x44,0x45,0x40,0x55,0xff,0xff,0x49,0x92,0x24,0x49,0x92,0x24,0xe8,0xbd,0x17,0x42,0x44,0x45,0x40,0x55,0xff,0xff,0x49,0x92,0x24,0x49,0x92,0x24,0x17,0xba,0xe8,0x45,0x11,0x10,0x15,0x00,0xff,0xff,0x49,0x92,0x24,0x49,0x92,0x24,0xf7,0x45,0x17,0x42,0x11,0x10,0x15,0x00,
]);

var wtu = WebGLTestUtils;
var contextVersion = wtu.getDefault3DContextVersion();
var canvas = document.getElementById("canvas");
var gl = wtu.create3DContext(canvas, {antialias: false});
var program = wtu.setupTexturedQuad(gl);
var ext = null;
var vao = null;
var validFormats = {
    COMPRESSED_SRGB_S3TC_DXT1_EXT       : 0x8C4C,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : 0x8C4D,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT : 0x8C4E,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : 0x8C4F,
};
var name;
var supportedFormats;

if (!gl) {
    testFailed("WebGL context does not exist");
} else {
    testPassed("WebGL context exists");

    // Run tests with extension disabled
    runTestDisabled();

    // Query the extension and store globally so shouldBe can access it
    ext = wtu.getExtensionWithKnownPrefixes(gl, "WEBGL_compressed_texture_s3tc_srgb");
    if (!ext) {
        testPassed("No WEBGL_compressed_texture_s3tc_srgb support -- this is legal");
        runSupportedTest(false);
    } else {
        testPassed("Successfully enabled WEBGL_compressed_texture_s3tc_srgb extension");

        runSupportedTest(true);
        runTestExtension();
    }
}

function runSupportedTest(extensionEnabled) {
    var name = wtu.getSupportedExtensionWithKnownPrefixes(gl, "WEBGL_compressed_texture_s3tc_srgb");
    if (name !== undefined) {
        if (extensionEnabled) {
            testPassed("WEBGL_compressed_texture_s3tc_srgb listed as supported and getExtension succeeded");
        } else {
            testFailed("WEBGL_compressed_texture_s3tc_srgb listed as supported but getExtension failed");
        }
    } else {
        if (extensionEnabled) {
            testFailed("WEBGL_compressed_texture_s3tc_srgb not listed as supported but getExtension succeeded");
        } else {
            testPassed("WEBGL_compressed_texture_s3tc_srgb not listed as supported and getExtension failed -- this is legal");
        }
    }
}


function runTestDisabled() {
    debug("Testing binding enum with extension disabled");

    supportedFormats = gl.getParameter(gl.COMPRESSED_TEXTURE_FORMATS);
    shouldBe("supportedFormats", "[]");
}

function formatExists(format, supportedFormats) {
    for (var ii = 0; ii < supportedFormats.length; ++ii) {
        if (format == supportedFormats[ii]) {
            testPassed("supported format " + formatToString(format) + " is exists");
            return;
        }
    }
    testFailed("supported format " + formatToString(format) + " does not exist");
}

function formatToString(format) {
    for (var p in ext) {
        if (ext[p] == format) {
            return p;
        }
    }
    return "0x" + format.toString(16);
}

function runTestExtension() {
    debug("Testing WEBGL_compressed_texture_s3tc_srgb");

    // check that all format enums exist.
    for (name in validFormats) {
        var expected = "0x" + validFormats[name].toString(16);
        var actual = "ext['" + name + "']";
        shouldBe(actual, expected);
    }

    supportedFormats = gl.getParameter(gl.COMPRESSED_TEXTURE_FORMATS);
    // There should be exactly 4 formats for both WebGL 1.0 and WebGL 2.0.
    shouldBe("supportedFormats.length", "4");

    // check that all 4 formats exist
    for (var name in validFormats.length) {
        formatExists(validFormats[name], supportedFormats);
    }

    // Test each format
    testDXT1_SRGB();
    testDXT1_SRGB_ALPHA();
    testDXT3_SRGB_ALPHA();
    testDXT5_SRGB_ALPHA();
}

function testDXT1_SRGB() {
    var tests = [
        {   width: 4,
            height: 4,
            channels: 3,
            data: img_4x4_rgb_dxt1,
            format: ext.COMPRESSED_SRGB_S3TC_DXT1_EXT,
            hasAlpha: false,
        },
        {   width: 8,
            height: 8,
            channels: 3,
            data: img_8x8_rgb_dxt1,
            format: ext.COMPRESSED_SRGB_S3TC_DXT1_EXT,
            hasAlpha: false,
        }
    ];
    testDXTTextures(tests);
}

function testDXT1_SRGB_ALPHA() {
    var tests = [
        {   width: 4,
            height: 4,
            channels: 4,
            data: img_4x4_rgba_dxt1,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
            // This is a special case -- the texture is still opaque
            // though it's RGBA.
            hasAlpha: false,
        },
        {   width: 8,
            height: 8,
            channels: 4,
            data: img_8x8_rgba_dxt1,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
            // This is a special case -- the texture is still opaque
            // though it's RGBA.
            hasAlpha: false,
        }
    ];
    testDXTTextures(tests);
}

function testDXT3_SRGB_ALPHA() {
    var tests = [
        {   width: 4,
            height: 4,
            channels: 4,
            data: img_4x4_rgba_dxt3,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
            hasAlpha: true,
        },
        {   width: 8,
            height: 8,
            channels: 4,
            data: img_8x8_rgba_dxt3,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
            hasAlpha: true,
        }
    ];
    testDXTTextures(tests);
}

function testDXT5_SRGB_ALPHA() {
    var tests = [
        {   width: 4,
            height: 4,
            channels: 4,
            data: img_4x4_rgba_dxt5,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
            hasAlpha: true,
        },
        {   width: 8,
            height: 8,
            channels: 4,
            data: img_8x8_rgba_dxt5,
            format: ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
            hasAlpha: true,
        }
    ];
    testDXTTextures(tests);
}

function testDXTTextures(tests) {
    debug("<hr/>");
    for (var ii = 0; ii < tests.length; ++ii) {
        testDXTTexture(tests[ii], false);
        if (contextVersion >= 2) {
            debug("<br/>");
            testDXTTexture(tests[ii], true);
        }
    }
}

function uncompressDXTBlockSRGB(
    destBuffer, destX, destY, destWidth, src, srcOffset, format) {
    function make565(src, offset) {
        return src[offset + 0] + src[offset + 1] * 256;
    }
    function make8888From565(c) {
        return [
                Math.floor(((c >> 11) & 0x1F) * 255 / 31),
                Math.floor(((c >>    5) & 0x3F) * 255 / 63),
                Math.floor(((c >>    0) & 0x1F) * 255 / 31),
                255
            ];
    }
    function mix(mult, c0, c1, div) {
        var r = [];
        for (var ii = 0; ii < c0.length; ++ii) {
            r[ii] = Math.floor((c0[ii] * mult + c1[ii]) / div);
        }
        return r;
    }
    var isDXT1 = format == ext.COMPRESSED_SRGB_S3TC_DXT1_EXT ||
                 format == ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
    var colorOffset = srcOffset + (isDXT1 ? 0 : 8);
    var color0 = make565(src, colorOffset + 0);
    var color1 = make565(src, colorOffset + 2);
    var c0gtc1 = color0 > color1 || !isDXT1;
    var rgba0 = make8888From565(color0);
    var rgba1 = make8888From565(color1);
    var colors = [
            rgba0,
            rgba1,
            c0gtc1 ? mix(2, rgba0, rgba1, 3) : mix(1, rgba0, rgba1, 2),
            c0gtc1 ? mix(2, rgba1, rgba0, 3) : [0, 0, 0, 255]
        ];

    // yea I know there is a lot of math in this inner loop.
    // so sue me.
    for (var yy = 0; yy < 4; ++yy) {
        var pixels = src[colorOffset + 4 + yy];
        for (var xx = 0; xx < 4; ++xx) {
            var dstOff = ((destY + yy) * destWidth + destX + xx) * 4;
            var code = (pixels >> (xx * 2)) & 0x3;
            var srcColor = colors[code];
            var alpha;
            switch (format) {
            case ext.COMPRESSED_SRGB_S3TC_DXT1_EXT:
                alpha = 255;
                break;
            case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
                alpha = (code == 3 && !c0gtc1) ? 0 : 255;
                break;
            case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
                {
                    var alpha0 = src[srcOffset + yy * 2 + Math.floor(xx / 2)];
                    var alpha1 = (alpha0 >> ((xx % 2) * 4)) & 0xF;
                    alpha = alpha1 | (alpha1 << 4);
                }
                break;
            case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
                {
                    var alpha0 = src[srcOffset + 0];
                    var alpha1 = src[srcOffset + 1];
                    var alphaOff = Math.floor(yy / 2) * 3 + 2;
                    var alphaBits =
                         src[srcOffset + alphaOff + 0] +
                         src[srcOffset + alphaOff + 1] * 256 +
                         src[srcOffset + alphaOff + 2] * 65536;
                    var alphaShift = (yy % 2) * 12 + xx * 3;
                    var alphaCode = (alphaBits >> alphaShift) & 0x7;
                    if (alpha0 > alpha1) {
                        switch (alphaCode) {
                        case 0:
                            alpha = alpha0;
                            break;
                        case 1:
                            alpha = alpha1;
                            break;
                        default:
                            alpha = ((8 - alphaCode) * alpha0 + (alphaCode - 1) * alpha1) / 7;
                            break;
                        }
                    } else {
                        switch (alphaCode) {
                        case 0:
                            alpha = alpha0;
                            break;
                        case 1:
                            alpha = alpha1;
                            break;
                        case 6:
                            alpha = 0;
                            break;
                        case 7:
                            alpha = 255;
                            break;
                        default:
                            alpha = ((6 - alphaCode) * alpha0 + (alphaCode - 1) * alpha1) / 5;
                            break;
                        }
                    }
                }
                break;
            default:
                throw "bad format";
            }
            destBuffer[dstOff + 0] = sRGBChannelToLinear(srcColor[0]);
            destBuffer[dstOff + 1] = sRGBChannelToLinear(srcColor[1]);
            destBuffer[dstOff + 2] = sRGBChannelToLinear(srcColor[2]);
            destBuffer[dstOff + 3] = alpha;
        }
    }
}

function getBlockSize(format) {
  var isDXT1 = format == ext.COMPRESSED_SRGB_S3TC_DXT1_EXT ||
               format == ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
  return isDXT1 ? 8 : 16;
}

function uncompressDXTSRGB(width, height, data, format) {
    if (width % 4 || height % 4) throw "bad width or height";

    var dest = new Uint8Array(width * height * 4);
    var blocksAcross = width / 4;
    var blocksDown = height / 4;
    var blockSize = getBlockSize(format);
    for (var yy = 0; yy < blocksDown; ++yy) {
        for (var xx = 0; xx < blocksAcross; ++xx) {
            uncompressDXTBlockSRGB(
                dest, xx * 4, yy * 4, width, data,
                (yy * blocksAcross + xx) * blockSize, format);
        }
    }
    return dest;
}

function copyRect(data, srcX, srcY, dstX, dstY, width, height, stride) {
  var bytesPerLine = width * 4;
  var srcOffset = srcX * 4 + srcY * stride;
  var dstOffset = dstX * 4 + dstY * stride;
  for (; height > 0; --height) {
    for (var ii = 0; ii < bytesPerLine; ++ii) {
      data[dstOffset + ii] = data[srcOffset + ii];
    }
    srcOffset += stride;
    dstOffset += stride;
  }
}

function testDXTTexture(test, useTexStorage) {
    var data = new Uint8Array(test.data);
    var width = test.width;
    var height = test.height;
    var format = test.format;

    var uncompressedData = uncompressDXTSRGB(width, height, data, format);

    canvas.width = width;
    canvas.height = height;
    gl.viewport(0, 0, width, height);
    debug("testing " + formatToString(format) + " " + width + "x" + height +
          (useTexStorage ? " via texStorage2D" : " via compressedTexImage2D"));

    var tex = gl.createTexture();
    gl.bindTexture(gl.TEXTURE_2D, tex);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    if (useTexStorage) {
        gl.texStorage2D(gl.TEXTURE_2D, 1, format, width, height);
        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "allocating compressed texture via texStorage2D");
        wtu.clearAndDrawUnitQuad(gl);
        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing unit quad");
        var clearColor = (test.hasAlpha ? [0, 0, 0, 0] : [0, 0, 0, 255]);
        wtu.checkCanvas(gl, clearColor, "texture should be initialized to black");
        gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, format, data);
        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "uploading compressed texture data via compressedTexSubImage2D");
    } else {
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height, 0, data);
        wtu.glErrorShouldBe(gl, gl.NO_ERROR, "uploading compressed texture");
    }
    gl.generateMipmap(gl.TEXTURE_2D);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "trying to generate mipmaps from compressed texture");
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "after clearing generateMipmap error");
    wtu.clearAndDrawUnitQuad(gl);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing unit quad 1");
    compareRect(width, height, test.channels, width, height, uncompressedData, data, format, "NEAREST");
    // Test again with linear filtering.
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
    wtu.clearAndDrawUnitQuad(gl);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing unit quad 2");
    compareRect(width, height, test.channels, width, height, uncompressedData, data, format, "LINEAR");

    if (!useTexStorage) {
        // It's not allowed to redefine textures defined via texStorage2D.
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height, 1, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "non 0 border");

        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width + 4, height, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height + 4, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width - 4, height, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height - 4, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");

        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width - 1, height, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width - 2, height, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height - 1, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
        gl.compressedTexImage2D(gl.TEXTURE_2D, 0, format, width, height - 2, 0, data);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");

        if (width == 4) {
            gl.compressedTexImage2D(gl.TEXTURE_2D, 1, format, 1, height, 0, data);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "valid dimensions for level > 0");
            gl.compressedTexImage2D(gl.TEXTURE_2D, 1, format, 2, height, 0, data);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "valid dimensions for level > 0");
        }
        if (height == 4) {
            gl.compressedTexImage2D(gl.TEXTURE_2D, 1, format, width, 1, 0, data);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "valid dimensions for level > 0");
            gl.compressedTexImage2D(gl.TEXTURE_2D, 1, format, width, 2, 0, data);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "valid dimensions for level > 0");
        }
    }

    // pick a wrong format that uses the same amount of data.
    var wrongFormat;
    switch (format) {
    case ext.COMPRESSED_SRGB_S3TC_DXT1_EXT:
      wrongFormat = ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
      break;
    case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
      wrongFormat = ext.COMPRESSED_SRGB_S3TC_DXT1_EXT;
      break;
    case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
      wrongFormat = ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
      break;
    case ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
      wrongFormat = ext.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
      break;
    }

    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, wrongFormat, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "format does not match");

    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 4, 0, width, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "dimension out of range");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 4, width, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "dimension out of range");

    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width + 4, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height + 4, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width - 4, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height - 4, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "data size does not match dimensions");

    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width - 1, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width - 2, height, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height - 1, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");
    gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height - 2, format, data);
    wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid dimensions");

    var subData = new Uint8Array(data.buffer, 0, getBlockSize(format));

    if (width == 8 && height == 8) {
        gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 1, 0, 4, 4, format, subData);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid offset");
        gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, 0, 1, 4, 4, format, subData);
        wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid offset");
    }

    var stride = width * 4;
    for (var yoff = 0; yoff < height; yoff += 4) {
        for (var xoff = 0; xoff < width; xoff += 4) {
            copyRect(uncompressedData, 0, 0, xoff, yoff, 4, 4, stride);
            gl.compressedTexSubImage2D(gl.TEXTURE_2D, 0, xoff, yoff, 4, 4, format, subData);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "uploading compressed texture");
            // First test NEAREST filtering.
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
            wtu.clearAndDrawUnitQuad(gl);
            compareRect(width, height, test.channels, width, height, uncompressedData, data, format, "NEAREST");
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing unit quad");
            // Next test LINEAR filtering.
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
            wtu.clearAndDrawUnitQuad(gl);
            wtu.glErrorShouldBe(gl, gl.NO_ERROR, "drawing unit quad");
            compareRect(width, height, test.channels, width, height, uncompressedData, data, format, "LINEAR");
        }
    }
}

function insertImg(element, caption, img) {
    var div = document.createElement("div");
    div.appendChild(img);
    var label = document.createElement("div");
    label.appendChild(document.createTextNode(caption));
    div.appendChild(label);
    element.appendChild(div);
}

function makeImage(imageWidth, imageHeight, dataWidth, data, alpha) {
    var scale = 8;
    var c = document.createElement("canvas");
    c.width = imageWidth * scale;
    c.height = imageHeight * scale;
    var ctx = c.getContext("2d");
    for (var yy = 0; yy < imageHeight; ++yy) {
        for (var xx = 0; xx < imageWidth; ++xx) {
            var offset = (yy * dataWidth + xx) * 4;
            ctx.fillStyle = "rgba(" +
                    data[offset + 0] + "," +
                    data[offset + 1] + "," +
                    data[offset + 2] + "," +
                    (alpha ? data[offset + 3] / 255 : 1) + ")";
            ctx.fillRect(xx * scale, yy * scale, scale, scale);
        }
    }
    return wtu.makeImageFromCanvas(c);
}

// See EXT_texture_sRGB, Section 3.8.x, sRGB Texture Color Conversion.
function sRGBChannelToLinear(value) {
    value = value / 255;
    if (value <= 0.04045) {
        value = value / 12.92;
    } else {
        value = Math.pow((value + 0.055) / 1.055, 2.4);
    }
    return Math.trunc(value * 255 + 0.5);
}

function compareRect(
        actualWidth, actualHeight, actualChannels,
        dataWidth, dataHeight, expectedData,
        testData, testFormat, filteringMode) {
    var actual = new Uint8Array(actualWidth * actualHeight * 4);
    gl.readPixels(
            0, 0, actualWidth, actualHeight, gl.RGBA, gl.UNSIGNED_BYTE, actual);
    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "reading back pixels");

    var div = document.createElement("div");
    div.className = "testimages";
    insertImg(div, "expected", makeImage(
            actualWidth, actualHeight, dataWidth, expectedData,
            actualChannels == 4));
    insertImg(div, "actual", makeImage(
            actualWidth, actualHeight, actualWidth, actual,
            actualChannels == 4));
    div.appendChild(document.createElement('br'));
    document.getElementById("console").appendChild(div);

    // This threshold is required because the values we get back from the
    // implementation don't exactly match our javascript implementation.
    // This is probably due to allowances in the way sRGB interacts with S3TC.
    var threshold = 2;
    var failed = false;
    for (var yy = 0; yy < actualHeight; ++yy) {
        for (var xx = 0; xx < actualWidth; ++xx) {
            var actualOffset = (yy * actualWidth + xx) * 4;
            var expectedOffset = (yy * dataWidth + xx) * 4;
            var expected = [
                    expectedData[expectedOffset + 0],
                    expectedData[expectedOffset + 1],
                    expectedData[expectedOffset + 2],
                    (actualChannels == 3 ? 255 : expectedData[expectedOffset + 3])
            ];
            for (var jj = 0; jj < 4; ++jj) {
                if (Math.abs(actual[actualOffset + jj] - expected[jj]) > threshold) {
                    failed = true;
                    var was = actual.slice(actualOffset, actualOffset + 4);
                    testFailed('at (' + xx + ', ' + yy + ') expected: '
                        + expected + ' ± ' + threshold + '; was ' + was);
                }
            }
        }
    }
    if (!failed) {
        testPassed("texture rendered correctly with " + filteringMode + " filtering");
    }
}

debug("");
var successfullyParsed = true;
</script>
<script src="../../js/js-test-post.js"></script>

</body>
</html>