Changeset 62145 in webkit

Timestamp:

Jun 29, 2010 1:16:52 PM (14 years ago)

Author:

kbr@google.com

Message:

2010-06-29 Kenneth Russell <​kbr@google.com>

Reviewed by Dimitri Glazkov.

Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView
​https://bugs.webkit.org/show_bug.cgi?id=40398

Added support for UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL pixel store
parameters to texImage2D and texSubImage2D entry points taking ArrayBufferView.
More cleanly separated the unpacking and packing phases of user-supplied pixel data
in GraphicsContext3D, and added support for unpack alignment. Fixed bug in handling
of unpackAlignment in GraphicsContext3D::flipVertically. Necessarily added
validation of the amount of data passed to texImage2D and texSubImage2D. Modified
fast/canvas/webgl/tex-image-with-format-and-type.html to include premultiplied alpha
tests for relevant source formats; added new test which exercises all combinations
of UNPACK_FLIP_Y_WEBGL, UNPACK_PREMULTIPLY_ALPHA_WEBGL, and UNPACK_ALIGNMENT pixel
store parameters.

Test: fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view.html

• html/canvas/WebGLRenderingContext.cpp: (WebCore::WebGLRenderingContext::texImage2D): (WebCore::WebGLRenderingContext::texSubImage2D): (WebCore::WebGLRenderingContext::validateTexFuncData):
• html/canvas/WebGLRenderingContext.h:
• platform/graphics/GraphicsContext3D.cpp: (WebCore::GraphicsContext3D::extractImageData): (WebCore::GraphicsContext3D::extractTextureData): (WebCore::GraphicsContext3D::flipVertically): (WebCore::doUnpackingAndPacking): (WebCore::computeIncrementParameters): (WebCore::doPacking): (WebCore::GraphicsContext3D::packPixels):
• platform/graphics/GraphicsContext3D.h: (WebCore::GraphicsContext3D::):
• platform/graphics/cg/GraphicsContext3DCG.cpp: (WebCore::GraphicsContext3D::getImageData):
• platform/graphics/qt/GraphicsContext3DQt.cpp: (WebCore::GraphicsContext3D::getImageData):
• platform/graphics/skia/GraphicsContext3DSkia.cpp: (WebCore::GraphicsContext3D::getImageData):

2010-06-29 Kenneth Russell <​kbr@google.com>

Reviewed by Dimitri Glazkov.

Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView
​https://bugs.webkit.org/show_bug.cgi?id=40398

Added support for UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL pixel store
parameters to texImage2D and texSubImage2D entry points taking ArrayBufferView.
More cleanly separated the unpacking and packing phases of user-supplied pixel data
in GraphicsContext3D, and added support for unpack alignment. Fixed bug in handling
of unpackAlignment in GraphicsContext3D::flipVertically. Necessarily added
validation of the amount of data passed to texImage2D and texSubImage2D. Modified
fast/canvas/webgl/tex-image-with-format-and-type.html to include premultiplied alpha
tests for relevant source formats; added new test which exercises all combinations
of UNPACK_FLIP_Y_WEBGL, UNPACK_PREMULTIPLY_ALPHA_WEBGL, and UNPACK_ALIGNMENT pixel
store parameters.

• fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view-expected.txt: Added.
• fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view.html: Added.
• fast/canvas/webgl/tex-image-with-format-and-type-expected.txt:
• fast/canvas/webgl/tex-image-with-format-and-type.html:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view-expected.txt (added)
• LayoutTests/fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view.html (added)
• LayoutTests/fast/canvas/webgl/tex-image-with-format-and-type-expected.txt (modified) (2 diffs)
• LayoutTests/fast/canvas/webgl/tex-image-with-format-and-type.html (modified) (20 diffs)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/html/canvas/WebGLRenderingContext.cpp (modified) (3 diffs)
• WebCore/html/canvas/WebGLRenderingContext.h (modified) (2 diffs)
• WebCore/platform/graphics/GraphicsContext3D.cpp (modified) (17 diffs)
• WebCore/platform/graphics/GraphicsContext3D.h (modified) (3 diffs)
• WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp (modified) (1 diff)
• WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp (modified) (1 diff)
• WebCore/platform/graphics/skia/GraphicsContext3DSkia.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2010-06-29  Kenneth Russell  <kbr@google.com>
+
+        Reviewed by Dimitri Glazkov.
+
+        Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView
+        https://bugs.webkit.org/show_bug.cgi?id=40398
+
+        Added support for UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL pixel store
+        parameters to texImage2D and texSubImage2D entry points taking ArrayBufferView.
+        More cleanly separated the unpacking and packing phases of user-supplied pixel data
+        in GraphicsContext3D, and added support for unpack alignment. Fixed bug in handling
+        of unpackAlignment in GraphicsContext3D::flipVertically. Necessarily added
+        validation of the amount of data passed to texImage2D and texSubImage2D. Modified
+        fast/canvas/webgl/tex-image-with-format-and-type.html to include premultiplied alpha
+        tests for relevant source formats; added new test which exercises all combinations
+        of UNPACK_FLIP_Y_WEBGL, UNPACK_PREMULTIPLY_ALPHA_WEBGL, and UNPACK_ALIGNMENT pixel
+        store parameters.
+
+        * fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view-expected.txt: Added.
+        * fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view.html: Added.
+        * fast/canvas/webgl/tex-image-with-format-and-type-expected.txt:
+        * fast/canvas/webgl/tex-image-with-format-and-type.html:
+
 2010-06-29  Robert Hogan  <robert@webkit.org>
 

trunk/LayoutTests/fast/canvas/webgl/tex-image-with-format-and-type-expected.txt

@@ -1 @@
-Verify texImage2D and texSubImage2D code paths taking HTML data with all format/type combinations
+Verify texImage2D and texSubImage2D code paths taking both HTML and user-specified data with all format/type combinations
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
-Regression test for https://bugs.webkit.org/show_bug.cgi?id=40319 : Implement format conversions in texImage2D and texSubImage2D taking HTML data
+Regression test for:
+https://bugs.webkit.org/show_bug.cgi?id=40319 : Implement format conversions in texImage2D and texSubImage2D taking HTML data
+https://bugs.webkit.org/show_bug.cgi?id=40398 : Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView
 Testing texImage2D with Image at 256x1
 PASS RGBA/UNSIGNED_BYTE should maintain full precision of data
@@ -132 +134 @@
 Testing texSubImage2D with ImageData at 256x1
 PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with LUMINANCE_ALPHA/UNSIGNED_BYTE
+Testing texImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_BYTE
+Testing texImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_SHORT_4_4_4_4
+Testing texImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_SHORT_5_5_5_1
+Testing texImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with LUMINANCE_ALPHA/UNSIGNED_BYTE
+Testing texSubImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_BYTE
+Testing texSubImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_SHORT_4_4_4_4
+Testing texSubImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_SHORT_5_5_5_1
+Testing texSubImage2D with raw data at 256x1
+PASS UNPACK_PREMULTIPLY_ALPHA_WEBGL with LUMINANCE_ALPHA/UNSIGNED_BYTE
 PASS successfullyParsed is true
 

trunk/LayoutTests/fast/canvas/webgl/tex-image-with-format-and-type.html

@@ -39 +39 @@
 var testCases = [];
 
+var DataMode = {
+    IMAGE: 0,
+    IMAGE_DATA: 1,
+
+    NUM_HTML_MODES: 2,
+
+    RAW_DATA: 2,
+
+    // This must remain the last mode.
+    NUM_MODES: 3
+};
+
 function init()
 {
@@ -47 +59 @@
     }
 
-    description('Verify texImage2D and texSubImage2D code paths taking HTML data with all format/type combinations');
-
-    debug('Regression test for <a href="https://bugs.webkit.org/show_bug.cgi?id=40319">https://bugs.webkit.org/show_bug.cgi?id=40319</a> : <code>Implement format conversions in texImage2D and texSubImage2D taking HTML data</code>');
+    description('Verify texImage2D and texSubImage2D code paths taking both HTML and user-specified data with all format/type combinations');
+
+    debug('Regression test for:');
+    debug('<a href="https://bugs.webkit.org/show_bug.cgi?id=40319">https://bugs.webkit.org/show_bug.cgi?id=40319</a> : <code>Implement format conversions in texImage2D and texSubImage2D taking HTML data</code>');
+    debug('<a href="https://bugs.webkit.org/show_bug.cgi?id=40398">https://bugs.webkit.org/show_bug.cgi?id=40398</a> : <code>Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView</code>');
 
     gl = initWebGL("example", "vshader", "fshader", [ "g_Position", "g_TexCoord0" ], [ 0, 0, 0, 1 ], 1);
@@ -92 +106 @@
     // Verify that uploading to packed pixel formats performs the
     // required conversion and associated loss of precision.
-    for (var useImageData = 0; useImageData < 2; ++useImageData) {
+    for (var dataMode = 0; dataMode < DataMode.NUM_HTML_MODES; ++dataMode) {
         for (var useTexSubImage2D = 0; useTexSubImage2D < 2; ++useTexSubImage2D) {
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -109 +123 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -123 +137 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -137 +151 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -151 +165 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -165 +179 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -179 +193 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -193 +207 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -212 +226 @@
     // store parameter and sending down a zero alpha causes the color
     // channels to go to zero.
-    for (var useImageData = 0; useImageData < 2; ++useImageData) {
+    for (var dataMode = 0; dataMode < DataMode.NUM_MODES; ++dataMode) {
         for (var useTexSubImage2D = 0; useTexSubImage2D < 2; ++useTexSubImage2D) {
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -227 +241 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -239 +253 @@
             });
             testCases.push({
-                useImageData: !!useImageData,
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -250 +264 @@
                 description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGBA/UNSIGNED_SHORT_5_5_5_1"
             });
-            testCases.push({
-                useImageData: !!useImageData,
-                useTexSubImage2D: !!useTexSubImage2D,
-                width: 256,
-                height: 1,
-                generator: generateTransparentGrayscaleRamp,
-                premultiplyAlpha: true,
-                format: gl.RGB,
-                type: gl.UNSIGNED_BYTE,
-                verifier: colorChannelsAreZero,
-                description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGB/UNSIGNED_BYTE"
-            });
-            testCases.push({
-                useImageData: !!useImageData,
-                useTexSubImage2D: !!useTexSubImage2D,
-                width: 256,
-                height: 1,
-                generator: generateTransparentGrayscaleRamp,
-                premultiplyAlpha: true,
-                format: gl.RGB,
-                type: gl.UNSIGNED_SHORT_5_6_5,
-                verifier: colorChannelsAreZero,
-                description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGB/UNSIGNED_SHORT_5_6_5"
-            });
-            testCases.push({
-                useImageData: !!useImageData,
-                useTexSubImage2D: !!useTexSubImage2D,
-                width: 256,
-                height: 1,
-                generator: generateTransparentGrayscaleRamp,
-                premultiplyAlpha: true,
-                format: gl.ALPHA,
-                type: gl.UNSIGNED_BYTE,
-                verifier: colorChannelsAreZero,
-                description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with ALPHA/UNSIGNED_BYTE"
-            });
-            testCases.push({
-                useImageData: !!useImageData,
-                useTexSubImage2D: !!useTexSubImage2D,
-                width: 256,
-                height: 1,
-                generator: generateTransparentGrayscaleRamp,
-                premultiplyAlpha: true,
-                format: gl.LUMINANCE,
-                type: gl.UNSIGNED_BYTE,
-                verifier: colorChannelsAreZero,
-                description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with LUMINANCE/UNSIGNED_BYTE"
-            });
-            testCases.push({
-                useImageData: !!useImageData,
+            // The following few tests are invalid for the raw data
+            // mode because there is either no alpha channel or no
+            // separate alpha channel.
+            if (dataMode != DataMode.RAW_DATA) {
+                testCases.push({
+                    dataMode: dataMode,
+                    useTexSubImage2D: !!useTexSubImage2D,
+                    width: 256,
+                    height: 1,
+                    generator: generateTransparentGrayscaleRamp,
+                    premultiplyAlpha: true,
+                    format: gl.RGB,
+                    type: gl.UNSIGNED_BYTE,
+                    verifier: colorChannelsAreZero,
+                    description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGB/UNSIGNED_BYTE"
+                });
+                testCases.push({
+                    dataMode: dataMode,
+                    useTexSubImage2D: !!useTexSubImage2D,
+                    width: 256,
+                    height: 1,
+                    generator: generateTransparentGrayscaleRamp,
+                    premultiplyAlpha: true,
+                    format: gl.RGB,
+                    type: gl.UNSIGNED_SHORT_5_6_5,
+                    verifier: colorChannelsAreZero,
+                    description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with RGB/UNSIGNED_SHORT_5_6_5"
+                });
+                testCases.push({
+                    dataMode: dataMode,
+                    useTexSubImage2D: !!useTexSubImage2D,
+                    width: 256,
+                    height: 1,
+                    generator: generateTransparentGrayscaleRamp,
+                    premultiplyAlpha: true,
+                    format: gl.ALPHA,
+                    type: gl.UNSIGNED_BYTE,
+                    verifier: colorChannelsAreZero,
+                    description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with ALPHA/UNSIGNED_BYTE"
+                });
+                testCases.push({
+                    dataMode: dataMode,
+                    useTexSubImage2D: !!useTexSubImage2D,
+                    width: 256,
+                    height: 1,
+                    generator: generateTransparentGrayscaleRamp,
+                    premultiplyAlpha: true,
+                    format: gl.LUMINANCE,
+                    type: gl.UNSIGNED_BYTE,
+                    verifier: colorChannelsAreZero,
+                    description: "UNPACK_PREMULTIPLY_ALPHA_WEBGL with LUMINANCE/UNSIGNED_BYTE"
+                });
+            }
+            testCases.push({
+                dataMode: dataMode,
                 useTexSubImage2D: !!useTexSubImage2D,
                 width: 256,
@@ -323 +342 @@
         var testCase = testCases[i];
         var wrapper = null;
-        if (testCase.useImageData)
+        switch (testCase.dataMode) {
+        case DataMode.IMAGE:
+            wrapper = new ImageWrapper(testCase.width, testCase.height);
+            break;
+        case DataMode.IMAGE_DATA:
             wrapper = new ImageDataWrapper(testCase.width, testCase.height);
-        else
-            wrapper = new ImageWrapper(testCase.width, testCase.height);
+            break;
+        case DataMode.RAW_DATA:
+            switch (testCase.type) {
+            case gl.UNSIGNED_BYTE:
+                switch (testCase.format) {
+                case gl.RGBA:
+                    wrapper = new RGBA8DataWrapper(testCase.width, testCase.height);
+                    break;
+                case gl.RGB:
+                    wrapper = new RGB8DataWrapper(testCase.width, testCase.height);
+                    break;
+                case gl.ALPHA:
+                    wrapper = new A8DataWrapper(testCase.width, testCase.height);
+                    break;
+                case gl.LUMINANCE:
+                    wrapper = new L8DataWrapper(testCase.width, testCase.height);
+                    break;
+                case gl.LUMINANCE_ALPHA:
+                    wrapper = new LA8DataWrapper(testCase.width, testCase.height);
+                    break;
+                }
+                break;
+            case gl.UNSIGNED_SHORT_4_4_4_4:
+                wrapper = new RGBA4444DataWrapper(testCase.width, testCase.height);
+                break;
+            case gl.UNSIGNED_SHORT_5_5_5_1:
+                wrapper = new RGBA5551DataWrapper(testCase.width, testCase.height);
+                break;
+            case gl.UNSIGNED_SHORT_5_6_5:
+                wrapper = new RGB565DataWrapper(testCase.width, testCase.height);
+                break;
+            }
+        }
         testCase.wrapper = wrapper;
         testCase.generator(wrapper);
@@ -360 +414 @@
 function testCaseToString(testCase)
 {
+    var mode;
+    switch (testCase.dataMode) {
+    case DataMode.IMAGE:
+        mode = "Image";
+        break;
+    case DataMode.IMAGE_DATA:
+        mode = "ImageData";
+        break;
+    case DataMode.RAW_DATA:
+        mode = "raw data";
+        break;
+    }
     return (testCase.useTexSubImage2D ? "texSubImage2D" : "texImage2D") +
-            " with " + (testCase.useImageData ? "ImageData" : "Image") +
-            " at " + testCase.width + "x" + testCase.height;
+            " with " + mode +  " at " + testCase.width + "x" + testCase.height;
 }
 
@@ -383 +448 @@
         gl.texImage2D(gl.TEXTURE_2D, 0, testCase.format, testCase.width, testCase.height, 0,
                       testCase.format, testCase.type, null);
-        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, testCase.format, testCase.type, data);
-    } else {
-        gl.texImage2D(gl.TEXTURE_2D, 0, testCase.format, testCase.format, testCase.type, data);
-    }
-
+    }
+    switch (testCase.dataMode) {
+    case DataMode.IMAGE:
+    case DataMode.IMAGE_DATA:
+        if (testCase.useTexSubImage2D)
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, testCase.format, testCase.type, data);
+        else
+            gl.texImage2D(gl.TEXTURE_2D, 0, testCase.format, testCase.format, testCase.type, data);
+        break;
+    case DataMode.RAW_DATA:
+        if (testCase.useTexSubImage2D)
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, testCase.width, testCase.height, testCase.format, testCase.type, data);
+        else
+            gl.texImage2D(gl.TEXTURE_2D, 0, testCase.format, testCase.width, testCase.height, 0, testCase.format, testCase.type, data);
+        break;
+    }
     // Point the uniform sampler to texture unit 0.
     gl.uniform1i(textureLoc, 0);
@@ -412 +488 @@
 
 //----------------------------------------------------------------------
-// Wrappers for programmatic construction of Image and ImageData
+// Wrappers for programmatic construction of Image, ImageData and raw texture data
 //
 
@@ -474 +550 @@
 };
 
+function TextureDataWrapper(width, height)
+{
+    this.width_ = width;
+    this.height_ = height;
+}
+
+TextureDataWrapper.prototype.getWidth = function() {
+    return this.width_;
+};
+
+TextureDataWrapper.prototype.getHeight = function() {
+    return this.height_;
+};
+
+TextureDataWrapper.prototype.generateData = function() {
+    this.data = this.data_;
+    maybeRunTests();
+};
+
+function RGBA8DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint8Array(4 * width * height);
+}
+
+RGBA8DataWrapper.prototype = new TextureDataWrapper;
+
+RGBA8DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var index = 4 * (this.width_ * y + x);
+    this.data_[index] = r;
+    this.data_[index + 1] = g;
+    this.data_[index + 2] = b;
+    this.data_[index + 3] = a;
+};
+
+function RGBA5551DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint16Array(width * height);
+}
+
+RGBA5551DataWrapper.prototype = new TextureDataWrapper;
+
+RGBA5551DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var value = (((r & 0xF8) << 8)
+                 | ((g & 0xF8) << 3)
+                 | ((b & 0xF8) >> 2)
+                 | (a >> 7));
+    this.data_[this.width_ * y + x] = value;
+};
+
+function RGBA4444DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint16Array(width * height);
+}
+
+RGBA4444DataWrapper.prototype = new TextureDataWrapper;
+
+RGBA4444DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var value = (((r & 0xF0) << 8)
+                 | ((g & 0xF0) << 4)
+                 | (b & 0xF0)
+                 | (a >> 4));
+    this.data_[this.width_ * y + x] = value;
+};
+
+function RGB8DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint8Array(3 * width * height);
+}
+
+RGB8DataWrapper.prototype = new TextureDataWrapper;
+
+RGB8DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var index = 3 * (this.width_ * y + x);
+    this.data_[index] = r;
+    this.data_[index + 1] = g;
+    this.data_[index + 2] = b;
+};
+
+function RGB565DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint16Array(width * height);
+}
+
+RGB565DataWrapper.prototype = new TextureDataWrapper;
+
+RGB565DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var value = (((r & 0xF8) << 8)
+                 | ((g & 0xFC) << 3)
+                 | ((b & 0xF8) >> 3));
+    this.data_[this.width_ * y + x] = value;
+};
+
+function A8DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint8Array(width * height);
+}
+
+A8DataWrapper.prototype = new TextureDataWrapper;
+
+A8DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    this.data_[this.width_ * y + x] = a;
+};
+
+function L8DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint8Array(width * height);
+}
+
+L8DataWrapper.prototype = new TextureDataWrapper;
+
+L8DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    this.data_[this.width_ * y + x] = r;
+};
+
+function LA8DataWrapper(width, height)
+{
+    TextureDataWrapper.call(this, width, height);
+    this.data_ = new Uint8Array(2 * width * height);
+}
+
+LA8DataWrapper.prototype = new TextureDataWrapper;
+
+LA8DataWrapper.prototype.setPixel = function(x, y, r, g, b, a) {
+    var index = 2 * (this.width_ * y + x);
+    this.data_[index] = r;
+    this.data_[index + 1] = a;
+};
+
 //----------------------------------------------------------------------
 // Color ramp generation functions
@@ -552 +763 @@
             if (array[i + j] != 0) {
                 passed = false;
-                if (++numFailures < 5)
-                    debug("  array[" + i + "] should have been 0, was " + array[i]);
+                if (++numFailures <= 5)
+                    debug("  array[" + (i + j) + "] should have been 0, was " + array[i + j]);
             }
 

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-06-29  Kenneth Russell  <kbr@google.com>
+
+        Reviewed by Dimitri Glazkov.
+
+        Support UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL for texImage2D taking ArrayBufferView
+        https://bugs.webkit.org/show_bug.cgi?id=40398
+
+        Added support for UNPACK_FLIP_Y_WEBGL and UNPACK_PREMULTIPLY_ALPHA_WEBGL pixel store
+        parameters to texImage2D and texSubImage2D entry points taking ArrayBufferView.
+        More cleanly separated the unpacking and packing phases of user-supplied pixel data
+        in GraphicsContext3D, and added support for unpack alignment. Fixed bug in handling
+        of unpackAlignment in GraphicsContext3D::flipVertically. Necessarily added
+        validation of the amount of data passed to texImage2D and texSubImage2D. Modified
+        fast/canvas/webgl/tex-image-with-format-and-type.html to include premultiplied alpha
+        tests for relevant source formats; added new test which exercises all combinations
+        of UNPACK_FLIP_Y_WEBGL, UNPACK_PREMULTIPLY_ALPHA_WEBGL, and UNPACK_ALIGNMENT pixel
+        store parameters.
+
+        Test: fast/canvas/webgl/tex-image-and-sub-image-2d-with-array-buffer-view.html
+
+        * html/canvas/WebGLRenderingContext.cpp:
+        (WebCore::WebGLRenderingContext::texImage2D):
+        (WebCore::WebGLRenderingContext::texSubImage2D):
+        (WebCore::WebGLRenderingContext::validateTexFuncData):
+        * html/canvas/WebGLRenderingContext.h:
+        * platform/graphics/GraphicsContext3D.cpp:
+        (WebCore::GraphicsContext3D::extractImageData):
+        (WebCore::GraphicsContext3D::extractTextureData):
+        (WebCore::GraphicsContext3D::flipVertically):
+        (WebCore::doUnpackingAndPacking):
+        (WebCore::computeIncrementParameters):
+        (WebCore::doPacking):
+        (WebCore::GraphicsContext3D::packPixels):
+        * platform/graphics/GraphicsContext3D.h:
+        (WebCore::GraphicsContext3D::):
+        * platform/graphics/cg/GraphicsContext3DCG.cpp:
+        (WebCore::GraphicsContext3D::getImageData):
+        * platform/graphics/qt/GraphicsContext3DQt.cpp:
+        (WebCore::GraphicsContext3D::getImageData):
+        * platform/graphics/skia/GraphicsContext3DSkia.cpp:
+        (WebCore::GraphicsContext3D::getImageData):
+
 2010-06-29  Patrick Gansterer  <paroga@paroga.com>
 

trunk/WebCore/html/canvas/WebGLRenderingContext.cpp

@@ -1994 +1994 @@
                                        unsigned format, unsigned type, ArrayBufferView* pixels, ExceptionCode& ec)
 {
-    // FIXME: Need to make sure passed buffer has enough bytes to define the texture
+    if (!validateTexFuncData(width, height, format, type, pixels))
+        return;
+    void* data = pixels ? pixels->baseAddress() : 0;
+    Vector<uint8_t> tempData;
+    bool changeUnpackAlignment = false;
+    if (pixels && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
+        if (!m_context->extractTextureData(width, height, format, type,
+                                           m_unpackAlignment,
+                                           m_unpackFlipY, m_unpackPremultiplyAlpha,
+                                           pixels,
+                                           tempData))
+            return;
+        data = tempData.data();
+        changeUnpackAlignment = true;
+    }
+    if (changeUnpackAlignment)
+        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
     texImage2DBase(target, level, internalformat, width, height, border,
-                   format, type, pixels ? pixels->baseAddress() : 0, ec);
+                   format, type, data, ec);
+    if (changeUnpackAlignment)
+        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
@@ -2250 +2268 @@
                                           unsigned format, unsigned type, ArrayBufferView* pixels, ExceptionCode& ec)
 {
-    // FIXME: Need to make sure passed buffer has enough bytes to define the texture
-    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, pixels ? pixels->baseAddress() : 0, ec);
+    if (!validateTexFuncData(width, height, format, type, pixels))
+        return;
+    void* data = pixels ? pixels->baseAddress() : 0;
+    Vector<uint8_t> tempData;
+    bool changeUnpackAlignment = false;
+    if (pixels && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
+        if (!m_context->extractTextureData(width, height, format, type,
+                                           m_unpackAlignment,
+                                           m_unpackFlipY, m_unpackPremultiplyAlpha,
+                                           pixels,
+                                           tempData))
+            return;
+        data = tempData.data();
+        changeUnpackAlignment = true;
+    }
+    if (changeUnpackAlignment)
+        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
+    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, ec);
+    if (changeUnpackAlignment)
+        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
@@ -3487 +3523 @@
 }
 
+bool WebGLRenderingContext::validateTexFuncData(long width, long height,
+                                                unsigned long format, unsigned long type,
+                                                ArrayBufferView* pixels)
+{
+    if (!pixels)
+        return true;
+
+    if (!validateTexFuncFormatAndType(format, type))
+        return false;
+
+    switch (type) {
+    case GraphicsContext3D::UNSIGNED_BYTE:
+        if (!pixels->isUnsignedByteArray()) {
+            m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
+            return false;
+        }
+        break;
+    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:
+    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:
+    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:
+        if (!pixels->isUnsignedShortArray()) {
+            m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
+            return false;
+        }
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+
+    unsigned long componentsPerPixel, bytesPerComponent;
+    if (!m_context->computeFormatAndTypeParameters(format, type, &componentsPerPixel, &bytesPerComponent)) {
+        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);
+        return false;
+    }
+
+    if (!width || !height)
+        return true;
+    unsigned int validRowBytes = width * componentsPerPixel * bytesPerComponent;
+    unsigned int totalRowBytes = validRowBytes;
+    unsigned int remainder = validRowBytes % m_unpackAlignment;
+    if (remainder)
+        totalRowBytes += (m_unpackAlignment - remainder);
+    unsigned int totalBytesRequired = (height - 1) * totalRowBytes + validRowBytes;
+    if (pixels->byteLength() < totalBytesRequired) {
+        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
+        return false;
+    }
+    return true;
+}
+
 bool WebGLRenderingContext::validateDrawMode(unsigned long mode)
 {

trunk/WebCore/html/canvas/WebGLRenderingContext.h

@@ -427 +427 @@
 
         // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
-        // Generate GL error and return false if parameters are invalid.
+        // Generates GL error and returns false if parameters are invalid.
         bool validateTexFuncFormatAndType(unsigned long format, unsigned long type);
 
         // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
-        // Generate GL error and return false if parameters are invalid.
+        // Generates GL error and returns false if parameters are invalid.
         bool validateTexFuncParameters(unsigned long target, long level,
                                        unsigned long internalformat,
@@ -437 +437 @@
                                        unsigned long format, unsigned long type);
 
+        // Helper function to validate that the given ArrayBufferView
+        // is of the correct type and contains enough data for the texImage call.
+        // Generates GL error and returns false if parameters are invalid.
+        bool validateTexFuncData(long width, long height,
+                                 unsigned long format, unsigned long type,
+                                 ArrayBufferView* pixels);
+
         // Helper function to validate mode for draw{Arrays/Elements}.
         bool validateDrawMode(unsigned long);

trunk/WebCore/platform/graphics/GraphicsContext3D.cpp

@@ -31 +31 @@
 #include "GraphicsContext3D.h"
 
+#include "ArrayBufferView.h"
 #include "Image.h"
 #include "ImageData.h"
@@ -119 +120 @@
                     width,
                     height,
+                    0,
                     format,
                     type,
@@ -139 +141 @@
 }
 
+bool GraphicsContext3D::extractTextureData(unsigned int width, unsigned int height,
+                                           unsigned int format, unsigned int type,
+                                           unsigned int unpackAlignment,
+                                           bool flipY, bool premultiplyAlpha,
+                                           ArrayBufferView* pixels,
+                                           Vector<uint8_t>& data)
+{
+    // Assumes format, type, etc. have already been validated.
+    SourceDataFormat sourceDataFormat = kSourceFormatRGBA8;
+    switch (type) {
+    case UNSIGNED_BYTE:
+        switch (format) {
+        case RGBA:
+            sourceDataFormat = kSourceFormatRGBA8;
+            break;
+        case RGB:
+            sourceDataFormat = kSourceFormatRGB8;
+            break;
+        case ALPHA:
+            sourceDataFormat = kSourceFormatA8;
+            break;
+        case LUMINANCE:
+            sourceDataFormat = kSourceFormatR8;
+            break;
+        case LUMINANCE_ALPHA:
+            sourceDataFormat = kSourceFormatRA8;
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+        }
+        break;
+    case UNSIGNED_SHORT_5_5_5_1:
+        sourceDataFormat = kSourceFormatRGBA5551;
+        break;
+    case UNSIGNED_SHORT_4_4_4_4:
+        sourceDataFormat = kSourceFormatRGBA4444;
+        break;
+    case UNSIGNED_SHORT_5_6_5:
+        sourceDataFormat = kSourceFormatRGB565;
+        break;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+
+    // Resize the output buffer.
+    unsigned long componentsPerPixel, bytesPerComponent;
+    if (!computeFormatAndTypeParameters(format, type,
+                                        &componentsPerPixel,
+                                        &bytesPerComponent))
+        return false;
+    unsigned long bytesPerPixel = componentsPerPixel * bytesPerComponent;
+    data.resize(width * height * bytesPerPixel);
+
+    if (!packPixels(static_cast<uint8_t*>(pixels->baseAddress()),
+                    sourceDataFormat,
+                    width, height, unpackAlignment,
+                    format, type,
+                    (premultiplyAlpha ? kAlphaDoPremultiply : kAlphaDoNothing),
+                    data.data()))
+        return false;
+    // The pixel data is now tightly packed.
+    if (flipY)
+        flipVertically(data.data(), width, height, bytesPerPixel, 1);
+    return true;
+}
+
 void GraphicsContext3D::flipVertically(void* imageData,
                                        unsigned int width,
@@ -151 +219 @@
     unsigned int remainder = validRowBytes % unpackAlignment;
     if (remainder)
-        totalRowBytes += remainder;
+        totalRowBytes += (unpackAlignment - remainder);
     uint8_t* tempRow = new uint8_t[validRowBytes];
     uint8_t* data = static_cast<uint8_t*>(imageData);
@@ -172 +240 @@
 // Pixel unpacking routines.
 
+void unpackRGBA8ToRGBA8(const uint8_t* source, uint8_t* destination)
+{
+    destination[0] = source[0];
+    destination[1] = source[1];
+    destination[2] = source[2];
+    destination[3] = source[3];
+}
+
 void unpackRGB8ToRGBA8(const uint8_t* source, uint8_t* destination)
 {
@@ -188 +264 @@
 }
 
+void unpackRGBA5551ToRGBA8(const uint16_t* source, uint8_t* destination)
+{
+    uint16_t packedValue = source[0];
+    uint8_t r = packedValue >> 11;
+    uint8_t g = (packedValue >> 6) & 0x1F;
+    uint8_t b = (packedValue >> 1) & 0x1F;
+    destination[0] = (r << 3) | (r & 0x7);
+    destination[1] = (g << 3) | (g & 0x7);
+    destination[2] = (b << 3) | (b & 0x7);
+    destination[3] = (packedValue & 0x1) ? 0xFF : 0x0;
+}
+
+void unpackRGBA4444ToRGBA8(const uint16_t* source, uint8_t* destination)
+{
+    uint16_t packedValue = source[0];
+    uint8_t r = packedValue >> 12;
+    uint8_t g = (packedValue >> 8) & 0x0F;
+    uint8_t b = (packedValue >> 4) & 0x0F;
+    uint8_t a = packedValue & 0x0F;
+    destination[0] = r << 4 | r;
+    destination[1] = g << 4 | g;
+    destination[2] = b << 4 | b;
+    destination[3] = a << 4 | a;
+}
+
+void unpackRGB565ToRGBA8(const uint16_t* source, uint8_t* destination)
+{
+    uint16_t packedValue = source[0];
+    uint8_t r = packedValue >> 11;
+    uint8_t g = (packedValue >> 5) & 0x3F;
+    uint8_t b = packedValue & 0x1F;
+    destination[0] = (r << 3) | (r & 0x7);
+    destination[1] = (g << 2) | (g & 0x3);
+    destination[2] = (b << 3) | (b & 0x7);
+    destination[3] = 0xFF;
+}
+
+void unpackR8ToRGBA8(const uint8_t* source, uint8_t* destination)
+{
+    destination[0] = source[0];
+    destination[1] = source[0];
+    destination[2] = source[0];
+    destination[3] = 0xFF;
+}
+
+void unpackRA8ToRGBA8(const uint8_t* source, uint8_t* destination)
+{
+    destination[0] = source[0];
+    destination[1] = source[0];
+    destination[2] = source[0];
+    destination[3] = source[1];
+}
+
+void unpackA8ToRGBA8(const uint8_t* source, uint8_t* destination)
+{
+    destination[0] = 0x0;
+    destination[1] = 0x0;
+    destination[2] = 0x0;
+    destination[3] = source[0];
+}
+
 //----------------------------------------------------------------------
 // Pixel packing routines.
@@ -402 +539 @@
 
 // This is used whenever unpacking is necessary; i.e., the source data
-// is not in RGBA8 format.
+// is not in RGBA8 format, or the unpack alignment specifies that rows
+// are not tightly packed.
 template<typename SourceType, typename DestType,
          void unpackingFunc(const SourceType*, uint8_t*),
          void packingFunc(const uint8_t*, DestType*)>
 static void doUnpackingAndPacking(const SourceType* sourceData,
-                                  unsigned int numElements,
+                                  unsigned int width,
+                                  unsigned int height,
                                   unsigned int sourceElementsPerPixel,
+                                  unsigned int sourceElementsPerRow,
                                   DestType* destinationData,
                                   unsigned int destinationElementsPerPixel)
 {
-    const SourceType* endPointer = sourceData + numElements;
-    uint8_t temporaryRGBAData[4];
-    while (sourceData < endPointer) {
-        unpackingFunc(sourceData, temporaryRGBAData);
-        packingFunc(temporaryRGBAData, destinationData);
-        sourceData += sourceElementsPerPixel;
-        destinationData += destinationElementsPerPixel;
-    }
-}
-
-// This handles all conversions with a faster path for RGBA8 source data.
-template<typename SourceType, typename DestType, void packingFunc(const SourceType*, DestType*)>
-static void doPacking(const SourceType* sourceData,
-                      GraphicsContext3D::SourceDataFormat sourceDataFormat,
-                      unsigned int numElements,
-                      unsigned int sourceElementsPerPixel,
-                      DestType* destinationData,
-                      unsigned int destinationElementsPerPixel)
-{
-    switch (sourceDataFormat) {
-    case GraphicsContext3D::kSourceFormatRGBA8: {
+    if (!sourceElementsPerRow) {
+        unsigned int numElements = width * height * sourceElementsPerPixel;
         const SourceType* endPointer = sourceData + numElements;
+        uint8_t temporaryRGBAData[4];
         while (sourceData < endPointer) {
-            packingFunc(sourceData, destinationData);
+            unpackingFunc(sourceData, temporaryRGBAData);
+            packingFunc(temporaryRGBAData, destinationData);
             sourceData += sourceElementsPerPixel;
             destinationData += destinationElementsPerPixel;
         }
+    } else {
+        uint8_t temporaryRGBAData[4];
+        for (unsigned int y = 0; y < height; ++y) {
+            const SourceType* currentSource = sourceData;
+            for (unsigned int x = 0; x < width; ++x) {
+                unpackingFunc(currentSource, temporaryRGBAData);
+                packingFunc(temporaryRGBAData, destinationData);
+                currentSource += sourceElementsPerPixel;
+                destinationData += destinationElementsPerPixel;
+            }
+            sourceData += sourceElementsPerRow;
+        }
+    }
+}
+
+template<typename SourceType>
+static void computeIncrementParameters(unsigned int width,
+                                       unsigned int bytesPerPixel,
+                                       unsigned int unpackAlignment,
+                                       unsigned int* sourceElementsPerPixel,
+                                       unsigned int* sourceElementsPerRow)
+{
+    unsigned int elementSizeInBytes = sizeof(SourceType);
+    ASSERT(elementSizeInBytes <= bytesPerPixel);
+    unsigned int validRowBytes = width * bytesPerPixel;
+    unsigned int totalRowBytes = validRowBytes;
+    if (unpackAlignment) {
+        unsigned int remainder = validRowBytes % unpackAlignment;
+        if (remainder)
+            totalRowBytes += (unpackAlignment - remainder);
+    }
+    *sourceElementsPerPixel = bytesPerPixel / elementSizeInBytes;
+    if (validRowBytes == totalRowBytes)
+        *sourceElementsPerRow = 0;
+    else
+        *sourceElementsPerRow = totalRowBytes / elementSizeInBytes;
+}
+
+// This handles all conversions with a faster path for tightly packed RGBA8 source data.
+template<typename DestType, void packingFunc(const uint8_t*, DestType*)>
+static void doPacking(const void* sourceData,
+                      GraphicsContext3D::SourceDataFormat sourceDataFormat,
+                      unsigned int width,
+                      unsigned int height,
+                      unsigned int sourceUnpackAlignment,
+                      DestType* destinationData,
+                      unsigned int destinationElementsPerPixel)
+{
+    switch (sourceDataFormat) {
+    case GraphicsContext3D::kSourceFormatRGBA8: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        if (!sourceElementsPerRow) {
+            const uint8_t* source = static_cast<const uint8_t*>(sourceData);
+            unsigned int numElements = width * height * 4;
+            const uint8_t* endPointer = source + numElements;
+            while (source < endPointer) {
+                packingFunc(source, destinationData);
+                source += sourceElementsPerPixel;
+                destinationData += destinationElementsPerPixel;
+            }
+        } else {
+            doUnpackingAndPacking<uint8_t, DestType, unpackRGBA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        }
         break;
     }
     case GraphicsContext3D::kSourceFormatRGB8: {
-        doUnpackingAndPacking<SourceType, DestType, unpackRGB8ToRGBA8, packingFunc>(sourceData, numElements, sourceElementsPerPixel, destinationData, destinationElementsPerPixel);
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 3, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint8_t, DestType, unpackRGB8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
         break;
     }
     case GraphicsContext3D::kSourceFormatBGRA8: {
-        doUnpackingAndPacking<SourceType, DestType, unpackBGRA8ToRGBA8, packingFunc>(sourceData, numElements, sourceElementsPerPixel, destinationData, destinationElementsPerPixel);
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint8_t, DestType, unpackBGRA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatRGBA5551: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint16_t, DestType, unpackRGBA5551ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatRGBA4444: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint16_t, DestType, unpackRGBA4444ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatRGB565: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint16_t, DestType, unpackRGB565ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatR8: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint8_t, DestType, unpackR8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatRA8: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint8_t, DestType, unpackRA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
+        break;
+    }
+    case GraphicsContext3D::kSourceFormatA8: {
+        unsigned int sourceElementsPerPixel, sourceElementsPerRow;
+        computeIncrementParameters<uint8_t>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow);
+        doUnpackingAndPacking<uint8_t, DestType, unpackA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel);
         break;
     }
@@ -456 +683 @@
                                    unsigned int width,
                                    unsigned int height,
+                                   unsigned int sourceUnpackAlignment,
                                    unsigned int destinationFormat,
                                    unsigned int destinationType,
@@ -461 +689 @@
                                    void* destinationData)
 {
-    unsigned int sourceElementsPerPixel = 4;
-    unsigned int numElements = width * height * sourceElementsPerPixel;
     switch (destinationType) {
     case UNSIGNED_BYTE: {
         uint8_t* destination = static_cast<uint8_t*>(destinationData);
-        if (sourceDataFormat == kSourceFormatRGBA8 && destinationFormat == RGBA && alphaOp == kAlphaDoNothing) {
+        if (sourceDataFormat == kSourceFormatRGBA8 && destinationFormat == RGBA && sourceUnpackAlignment <= 4 && alphaOp == kAlphaDoNothing) {
             // No conversion necessary.
-            memcpy(destinationData, sourceData, numElements);
+            memcpy(destinationData, sourceData, width * height * 4);
             break;
         }
@@ -475 +701 @@
             switch (alphaOp) {
             case kAlphaDoNothing:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGB8>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 3);
+                doPacking<uint8_t, packRGBA8ToRGB8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3);
                 break;
             case kAlphaDoPremultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGB8Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 3);
+                doPacking<uint8_t, packRGBA8ToRGB8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3);
                 break;
             case kAlphaDoUnmultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGB8Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 3);
+                doPacking<uint8_t, packRGBA8ToRGB8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3);
                 break;
             }
@@ -488 +714 @@
             switch (alphaOp) {
             case kAlphaDoNothing:
-                ASSERT(sourceDataFormat != kSourceFormatRGBA8); // Handled above with fast case.
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGBA8>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 4);
+                ASSERT(sourceDataFormat != kSourceFormatRGBA8 || sourceUnpackAlignment > 4); // Handled above with fast case.
+                doPacking<uint8_t, packRGBA8ToRGBA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4);
                 break;
             case kAlphaDoPremultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGBA8Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 4);
+                doPacking<uint8_t, packRGBA8ToRGBA8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4);
                 break;
             case kAlphaDoUnmultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRGBA8Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 4);
+                doPacking<uint8_t, packRGBA8ToRGBA8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4);
                 break;
             default:
@@ -505 +731 @@
             // specification, Table 3.15), the alpha channel is chosen
             // from the RGBA data.
-            doPacking<uint8_t, uint8_t, packRGBA8ToA8>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint8_t, packRGBA8ToA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case LUMINANCE:
@@ -513 +739 @@
             switch (alphaOp) {
             case kAlphaDoNothing:
-                doPacking<uint8_t, uint8_t, packRGBA8ToR8>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+                doPacking<uint8_t, packRGBA8ToR8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
                 break;
             case kAlphaDoPremultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToR8Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+                doPacking<uint8_t, packRGBA8ToR8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
                 break;
             case kAlphaDoUnmultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToR8Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+                doPacking<uint8_t, packRGBA8ToR8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
                 break;
             }
@@ -529 +755 @@
             switch (alphaOp) {
             case kAlphaDoNothing:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRA8>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 2);
+                doPacking<uint8_t, packRGBA8ToRA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2);
                 break;
             case kAlphaDoPremultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRA8Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 2);
+                doPacking<uint8_t, packRGBA8ToRA8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2);
                 break;
             case kAlphaDoUnmultiply:
-                doPacking<uint8_t, uint8_t, packRGBA8ToRA8Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 2);
+                doPacking<uint8_t, packRGBA8ToRA8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2);
                 break;
             }
@@ -546 +772 @@
         switch (alphaOp) {
         case kAlphaDoNothing:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort4444>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort4444>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoPremultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort4444Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort4444Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoUnmultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort4444Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort4444Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         }
@@ -561 +787 @@
         switch (alphaOp) {
         case kAlphaDoNothing:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort5551>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort5551>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoPremultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort5551Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort5551Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoUnmultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort5551Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort5551Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         }
@@ -576 +802 @@
         switch (alphaOp) {
         case kAlphaDoNothing:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort565>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort565>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoPremultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort565Premultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort565Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         case kAlphaDoUnmultiply:
-            doPacking<uint8_t, uint16_t, packRGBA8ToUnsignedShort565Unmultiply>(sourceData, sourceDataFormat, numElements, sourceElementsPerPixel, destination, 1);
+            doPacking<uint16_t, packRGBA8ToUnsignedShort565Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1);
             break;
         }

trunk/WebCore/platform/graphics/GraphicsContext3D.h

@@ -499 +499 @@
                               Vector<uint8_t>& data);
 
+        // Helper function which extracts the user-supplied texture
+        // data, applying the flipY and premultiplyAlpha parameters.
+        // If the data is not tightly packed according to the passed
+        // unpackAlignment, the output data will be tightly packed.
+        // Returns true if successful, false if any error occurred.
+        bool extractTextureData(unsigned int width, unsigned int height,
+                                unsigned int format, unsigned int type,
+                                unsigned int unpackAlignment,
+                                bool flipY, bool premultiplyAlpha,
+                                ArrayBufferView* pixels,
+                                Vector<uint8_t>& data);
+
         // Flips the given image data vertically, in-place.
         void flipVertically(void* imageData,
@@ -513 +525 @@
             kSourceFormatRGBA8,
             kSourceFormatRGB8,
-            kSourceFormatBGRA8
+            kSourceFormatBGRA8,
+            kSourceFormatRGBA5551,
+            kSourceFormatRGBA4444,
+            kSourceFormatRGB565,
+            kSourceFormatR8,
+            kSourceFormatRA8,
+            kSourceFormatA8
         };
 
@@ -757 +775 @@
         // Helper for getImageData which implements packing of pixel
         // data into the specified OpenGL destination format and type.
-        // Source data must be in RGBA format with no gaps between
-        // rows. Destination data will have no gaps between rows.
+        // A sourceUnpackAlignment of zero indicates that the source
+        // data is tightly packed. Non-zero values may take a slow path.
+        // Destination data will have no gaps between rows.
         bool packPixels(const uint8_t* sourceData,
                         SourceDataFormat sourceDataFormat,
                         unsigned int width,
                         unsigned int height,
+                        unsigned int sourceUnpackAlignment,
                         unsigned int destinationFormat,
                         unsigned int destinationType,

trunk/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp

@@ -101 +101 @@
         // FIXME: must fetch the image data before the premultiplication step.
         neededAlphaOp = kAlphaDoUnmultiply;
-    return packPixels(tempVector.data(), kSourceFormatRGBA8, width, height,
+    return packPixels(tempVector.data(), kSourceFormatRGBA8, width, height, 0,
                       format, type, neededAlphaOp, outputVector.data());
 }

trunk/WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp

@@ -1638 +1638 @@
     QImage nativeImage = nativePixmap->toImage().convertToFormat(QImage::Format_ARGB32);
     outputVector.resize(nativeImage.byteCount());
-    return packPixels(nativeImage.rgbSwapped().bits(), kSourceFormatRGBA8, image->width(), image->height(),
+    return packPixels(nativeImage.rgbSwapped().bits(), kSourceFormatRGBA8, image->width(), image->height(), 0,
                       format, type, neededAlphaOp, outputVector.data());
 }

trunk/WebCore/platform/graphics/skia/GraphicsContext3DSkia.cpp

@@ -64 +64 @@
         // FIXME: must fetch the image data before the premultiplication step
         neededAlphaOp = kAlphaDoUnmultiply;
-    return packPixels(pixels, kSourceFormatBGRA8, skiaImage->width(), height,
+    return packPixels(pixels, kSourceFormatBGRA8, skiaImage->width(), height, 0,
                       format, type, neededAlphaOp, outputVector.data());
 }