Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision b'e58cde68851afa192214f60a021f1e56b4172b7a'

Browse source
This commit is contained in:
WPT Sync Bot 2021-03-04 08:19:34 +00:00
parent 902af56b80
commit 885a29c0ba
197 changed files with 2096 additions and 2151 deletions
Download patch file Download diff file Expand all files Collapse all files

111
tests/wpt/web-platform-tests/webcodecs/image-decoder-utils.js Normal file
View file

@ -0,0 +1,111 @@
function toUInt32(pixelArray) {
let p = pixelArray.data;
return ((p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]) >>> 0;
}
function flipMatrix(m) {
return m.map(row => row.reverse());
}
function rotateMatrix(m, count) {
for (var i = 0; i < count; ++i)
m = m[0].map((val, index) => m.map(row => row[index]).reverse());
return m;
}
function testFourColorDecodeWithExifOrientation(orientation, canvas) {
return fetch('four-colors.jpg')
.then(response => {
return response.arrayBuffer();
})
.then(buffer => {
let u8buffer = new Uint8Array(buffer);
u8buffer[0x1F] = orientation; // Location derived via diff.
let decoder = new ImageDecoder({data: u8buffer, type: 'image/jpeg'});
return decoder.decode();
})
.then(result => {
let respectOrientation = true;
if (canvas)
respectOrientation = canvas.style.imageOrientation != 'none';
let expectedWidth = 320;
let expectedHeight = 240;
if (orientation > 4 && respectOrientation)
[expectedWidth, expectedHeight] = [expectedHeight, expectedWidth];
if (respectOrientation) {
assert_equals(result.image.displayWidth, expectedWidth);
assert_equals(result.image.displayHeight, expectedHeight);
} else if (orientation > 4) {
assert_equals(result.image.displayHeight, expectedWidth);
assert_equals(result.image.displayWidth, expectedHeight);
}
if (!canvas) {
canvas = new OffscreenCanvas(
result.image.displayWidth, result.image.displayHeight);
} else {
canvas.width = expectedWidth;
canvas.height = expectedHeight;
}
let ctx = canvas.getContext('2d');
ctx.drawImage(result.image, 0, 0);
let matrix = [
[0xFFFF00FF, 0xFF0000FF], // yellow, red
[0x0000FFFF, 0x00FF00FF], // blue, green
];
if (respectOrientation) {
switch (orientation) {
case 1: // kOriginTopLeft, default
break;
case 2: // kOriginTopRight, mirror along y-axis
matrix = flipMatrix(matrix);
break;
case 3: // kOriginBottomRight, 180 degree rotation
matrix = rotateMatrix(matrix, 2);
break;
case 4: // kOriginBottomLeft, mirror along the x-axis
matrix = flipMatrix(rotateMatrix(matrix, 2));
break;
case 5: // kOriginLeftTop, mirror along x-axis + 270 degree CW
// rotation
matrix = flipMatrix(rotateMatrix(matrix, 1));
break;
case 6: // kOriginRightTop, 90 degree CW rotation
matrix = rotateMatrix(matrix, 1);
break;
case 7: // kOriginRightBottom, mirror along x-axis + 90 degree CW
// rotation
matrix = flipMatrix(rotateMatrix(matrix, 3));
break;
case 8: // kOriginLeftBottom, 270 degree CW rotation
matrix = rotateMatrix(matrix, 3);
break;
default:
assert_between_inclusive(
orientation, 1, 8, 'unknown image orientation');
break;
};
}
let expectedTopLeft = matrix[0][0];
let expectedTopRight = matrix[0][1];
let expectedBottomLeft = matrix[1][0];
let expectedBottomRight = matrix[1][1];
let topLeft = toUInt32(ctx.getImageData(0, 0, 1, 1));
let topRight = toUInt32(ctx.getImageData(expectedWidth - 1, 0, 1, 1));
let bottomLeft =
toUInt32(ctx.getImageData(0, expectedHeight - 1, 1, 1));
let bottomRight = toUInt32(
ctx.getImageData(expectedWidth - 1, expectedHeight - 1, 1, 1));
assert_equals(topLeft, expectedTopLeft, 'top left corner');
assert_equals(topRight, expectedTopRight, 'top right corner');
assert_equals(bottomLeft, expectedBottomLeft, 'bottom left corner');
assert_equals(bottomRight, expectedBottomRight, 'bottom right corner');
});
}