1 /* 2 * Copyright (C) 2010 Apple Inc. All rights reserved. 3 * Copyright (C) 2010 Google Inc. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "config.h" 28 29 #if ENABLE(WEBGL) 30 31 #include "GraphicsContext3D.h" 32 33 #include "ArrayBufferView.h" 34 #include "CheckedInt.h" 35 #include "DrawingBuffer.h" 36 #include "Extensions3D.h" 37 #include "Image.h" 38 #include "ImageData.h" 39 40 #include <wtf/OwnArrayPtr.h> 41 #include <wtf/PassOwnArrayPtr.h> 42 43 namespace WebCore { 44 45 namespace { 46 47 uint8_t convertColor16LittleTo8(uint16_t value) 48 { 49 return value >> 8; 50 } 51 52 uint8_t convertColor16BigTo8(uint16_t value) 53 { 54 return static_cast<uint8_t>(value & 0x00FF); 55 } 56 57 } // anonymous namespace 58 59 60 PassRefPtr<DrawingBuffer> GraphicsContext3D::createDrawingBuffer(const IntSize& size) 61 { 62 return DrawingBuffer::create(this, size); 63 } 64 65 bool GraphicsContext3D::texImage2DResourceSafe(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint unpackAlignment) 66 { 67 ASSERT(unpackAlignment == 1 || unpackAlignment == 2 || unpackAlignment == 4 || unpackAlignment == 8); 68 OwnArrayPtr<unsigned char> zero; 69 if (width > 0 && height > 0) { 70 unsigned int size; 71 GC3Denum error = computeImageSizeInBytes(format, type, width, height, unpackAlignment, &size, 0); 72 if (error != GraphicsContext3D::NO_ERROR) { 73 synthesizeGLError(error); 74 return false; 75 } 76 zero = adoptArrayPtr(new unsigned char[size]); 77 if (!zero) { 78 synthesizeGLError(GraphicsContext3D::INVALID_VALUE); 79 return false; 80 } 81 memset(zero.get(), 0, size); 82 } 83 return texImage2D(target, level, internalformat, width, height, border, format, type, zero.get()); 84 } 85 86 bool GraphicsContext3D::computeFormatAndTypeParameters(GC3Denum format, 87 GC3Denum type, 88 unsigned int* componentsPerPixel, 89 unsigned int* bytesPerComponent) 90 { 91 switch (format) { 92 case GraphicsContext3D::ALPHA: 93 *componentsPerPixel = 1; 94 break; 95 case GraphicsContext3D::LUMINANCE: 96 *componentsPerPixel = 1; 97 break; 98 case GraphicsContext3D::LUMINANCE_ALPHA: 99 *componentsPerPixel = 2; 100 break; 101 case GraphicsContext3D::RGB: 102 *componentsPerPixel = 3; 103 break; 104 case GraphicsContext3D::RGBA: 105 case Extensions3D::BGRA_EXT: // GL_EXT_texture_format_BGRA8888 106 *componentsPerPixel = 4; 107 break; 108 default: 109 return false; 110 } 111 switch (type) { 112 case GraphicsContext3D::UNSIGNED_BYTE: 113 *bytesPerComponent = sizeof(GC3Dubyte); 114 break; 115 case GraphicsContext3D::UNSIGNED_SHORT_5_6_5: 116 case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4: 117 case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1: 118 *componentsPerPixel = 1; 119 *bytesPerComponent = sizeof(GC3Dushort); 120 break; 121 case GraphicsContext3D::FLOAT: // OES_texture_float 122 *bytesPerComponent = sizeof(GC3Dfloat); 123 break; 124 default: 125 return false; 126 } 127 return true; 128 } 129 130 GC3Denum GraphicsContext3D::computeImageSizeInBytes(GC3Denum format, GC3Denum type, GC3Dsizei width, GC3Dsizei height, GC3Dint alignment, 131 unsigned int* imageSizeInBytes, unsigned int* paddingInBytes) 132 { 133 ASSERT(imageSizeInBytes); 134 ASSERT(alignment == 1 || alignment == 2 || alignment == 4 || alignment == 8); 135 if (width < 0 || height < 0) 136 return GraphicsContext3D::INVALID_VALUE; 137 unsigned int bytesPerComponent, componentsPerPixel; 138 if (!computeFormatAndTypeParameters(format, type, &bytesPerComponent, &componentsPerPixel)) 139 return GraphicsContext3D::INVALID_ENUM; 140 if (!width || !height) { 141 *imageSizeInBytes = 0; 142 if (paddingInBytes) 143 *paddingInBytes = 0; 144 return GraphicsContext3D::NO_ERROR; 145 } 146 CheckedInt<uint32_t> checkedValue(bytesPerComponent * componentsPerPixel); 147 checkedValue *= width; 148 if (!checkedValue.valid()) 149 return GraphicsContext3D::INVALID_VALUE; 150 unsigned int validRowSize = checkedValue.value(); 151 unsigned int padding = 0; 152 unsigned int residual = validRowSize % alignment; 153 if (residual) { 154 padding = alignment - residual; 155 checkedValue += padding; 156 } 157 // Last row needs no padding. 158 checkedValue *= (height - 1); 159 checkedValue += validRowSize; 160 if (!checkedValue.valid()) 161 return GraphicsContext3D::INVALID_VALUE; 162 *imageSizeInBytes = checkedValue.value(); 163 if (paddingInBytes) 164 *paddingInBytes = padding; 165 return GraphicsContext3D::NO_ERROR; 166 } 167 168 bool GraphicsContext3D::extractImageData(Image* image, 169 GC3Denum format, 170 GC3Denum type, 171 bool flipY, 172 bool premultiplyAlpha, 173 bool ignoreGammaAndColorProfile, 174 Vector<uint8_t>& data) 175 { 176 if (!image) 177 return false; 178 if (!getImageData(image, format, type, premultiplyAlpha, ignoreGammaAndColorProfile, data)) 179 return false; 180 if (flipY) { 181 unsigned int componentsPerPixel, bytesPerComponent; 182 if (!computeFormatAndTypeParameters(format, type, 183 &componentsPerPixel, 184 &bytesPerComponent)) 185 return false; 186 // The image data is tightly packed, and we upload it as such. 187 unsigned int unpackAlignment = 1; 188 flipVertically(data.data(), image->width(), image->height(), 189 componentsPerPixel * bytesPerComponent, 190 unpackAlignment); 191 } 192 return true; 193 } 194 195 bool GraphicsContext3D::extractImageData(ImageData* imageData, 196 GC3Denum format, 197 GC3Denum type, 198 bool flipY, 199 bool premultiplyAlpha, 200 Vector<uint8_t>& data) 201 { 202 if (!imageData) 203 return false; 204 int width = imageData->width(); 205 int height = imageData->height(); 206 int dataBytes = width * height * 4; 207 data.resize(dataBytes); 208 if (!packPixels(imageData->data()->data()->data(), 209 SourceFormatRGBA8, 210 width, 211 height, 212 0, 213 format, 214 type, 215 premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing, 216 data.data())) 217 return false; 218 if (flipY) { 219 unsigned int componentsPerPixel, bytesPerComponent; 220 if (!computeFormatAndTypeParameters(format, type, 221 &componentsPerPixel, 222 &bytesPerComponent)) 223 return false; 224 // The image data is tightly packed, and we upload it as such. 225 unsigned int unpackAlignment = 1; 226 flipVertically(data.data(), width, height, 227 componentsPerPixel * bytesPerComponent, 228 unpackAlignment); 229 } 230 return true; 231 } 232 233 bool GraphicsContext3D::extractTextureData(unsigned int width, unsigned int height, 234 GC3Denum format, GC3Denum type, 235 unsigned int unpackAlignment, 236 bool flipY, bool premultiplyAlpha, 237 const void* pixels, 238 Vector<uint8_t>& data) 239 { 240 // Assumes format, type, etc. have already been validated. 241 SourceDataFormat sourceDataFormat = SourceFormatRGBA8; 242 switch (type) { 243 case UNSIGNED_BYTE: 244 switch (format) { 245 case RGBA: 246 sourceDataFormat = SourceFormatRGBA8; 247 break; 248 case RGB: 249 sourceDataFormat = SourceFormatRGB8; 250 break; 251 case ALPHA: 252 sourceDataFormat = SourceFormatA8; 253 break; 254 case LUMINANCE: 255 sourceDataFormat = SourceFormatR8; 256 break; 257 case LUMINANCE_ALPHA: 258 sourceDataFormat = SourceFormatRA8; 259 break; 260 default: 261 ASSERT_NOT_REACHED(); 262 } 263 break; 264 case FLOAT: // OES_texture_float 265 switch (format) { 266 case RGBA: 267 sourceDataFormat = SourceFormatRGBA32F; 268 break; 269 case RGB: 270 sourceDataFormat = SourceFormatRGB32F; 271 break; 272 case ALPHA: 273 sourceDataFormat = SourceFormatA32F; 274 break; 275 case LUMINANCE: 276 sourceDataFormat = SourceFormatR32F; 277 break; 278 case LUMINANCE_ALPHA: 279 sourceDataFormat = SourceFormatRA32F; 280 break; 281 default: 282 ASSERT_NOT_REACHED(); 283 } 284 break; 285 case UNSIGNED_SHORT_5_5_5_1: 286 sourceDataFormat = SourceFormatRGBA5551; 287 break; 288 case UNSIGNED_SHORT_4_4_4_4: 289 sourceDataFormat = SourceFormatRGBA4444; 290 break; 291 case UNSIGNED_SHORT_5_6_5: 292 sourceDataFormat = SourceFormatRGB565; 293 break; 294 default: 295 ASSERT_NOT_REACHED(); 296 } 297 298 // Resize the output buffer. 299 unsigned int componentsPerPixel, bytesPerComponent; 300 if (!computeFormatAndTypeParameters(format, type, 301 &componentsPerPixel, 302 &bytesPerComponent)) 303 return false; 304 unsigned int bytesPerPixel = componentsPerPixel * bytesPerComponent; 305 data.resize(width * height * bytesPerPixel); 306 307 if (!packPixels(static_cast<const uint8_t*>(pixels), 308 sourceDataFormat, 309 width, height, unpackAlignment, 310 format, type, 311 (premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing), 312 data.data())) 313 return false; 314 // The pixel data is now tightly packed. 315 if (flipY) 316 flipVertically(data.data(), width, height, bytesPerPixel, 1); 317 return true; 318 } 319 320 void GraphicsContext3D::flipVertically(void* imageData, 321 unsigned int width, 322 unsigned int height, 323 unsigned int bytesPerPixel, 324 unsigned int unpackAlignment) 325 { 326 if (!width || !height) 327 return; 328 unsigned int validRowBytes = width * bytesPerPixel; 329 unsigned int totalRowBytes = validRowBytes; 330 unsigned int remainder = validRowBytes % unpackAlignment; 331 if (remainder) 332 totalRowBytes += (unpackAlignment - remainder); 333 uint8_t* tempRow = new uint8_t[validRowBytes]; 334 uint8_t* data = static_cast<uint8_t*>(imageData); 335 for (unsigned i = 0; i < height / 2; i++) { 336 uint8_t* lowRow = data + (totalRowBytes * i); 337 uint8_t* highRow = data + (totalRowBytes * (height - i - 1)); 338 memcpy(tempRow, lowRow, validRowBytes); 339 memcpy(lowRow, highRow, validRowBytes); 340 memcpy(highRow, tempRow, validRowBytes); 341 } 342 delete[] tempRow; 343 } 344 345 // These functions can not be static, or gcc will not allow them to be 346 // used as template parameters. Use an anonymous namespace to prevent 347 // the need to declare prototypes for them. 348 namespace { 349 350 //---------------------------------------------------------------------- 351 // Pixel unpacking routines. 352 353 void unpackRGBA8ToRGBA8(const uint8_t* source, uint8_t* destination) 354 { 355 destination[0] = source[0]; 356 destination[1] = source[1]; 357 destination[2] = source[2]; 358 destination[3] = source[3]; 359 } 360 361 void unpackRGBA16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 362 { 363 destination[0] = convertColor16LittleTo8(source[0]); 364 destination[1] = convertColor16LittleTo8(source[1]); 365 destination[2] = convertColor16LittleTo8(source[2]); 366 destination[3] = convertColor16LittleTo8(source[3]); 367 } 368 369 void unpackRGBA16BigToRGBA8(const uint16_t* source, uint8_t* destination) 370 { 371 destination[0] = convertColor16BigTo8(source[0]); 372 destination[1] = convertColor16BigTo8(source[1]); 373 destination[2] = convertColor16BigTo8(source[2]); 374 destination[3] = convertColor16BigTo8(source[3]); 375 } 376 377 void unpackRGB8ToRGBA8(const uint8_t* source, uint8_t* destination) 378 { 379 destination[0] = source[0]; 380 destination[1] = source[1]; 381 destination[2] = source[2]; 382 destination[3] = 0xFF; 383 } 384 385 void unpackRGB16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 386 { 387 destination[0] = convertColor16LittleTo8(source[0]); 388 destination[1] = convertColor16LittleTo8(source[1]); 389 destination[2] = convertColor16LittleTo8(source[2]); 390 destination[3] = 0xFF; 391 } 392 393 void unpackRGB16BigToRGBA8(const uint16_t* source, uint8_t* destination) 394 { 395 destination[0] = convertColor16BigTo8(source[0]); 396 destination[1] = convertColor16BigTo8(source[1]); 397 destination[2] = convertColor16BigTo8(source[2]); 398 destination[3] = 0xFF; 399 } 400 401 void unpackBGR8ToRGBA8(const uint8_t* source, uint8_t* destination) 402 { 403 destination[0] = source[2]; 404 destination[1] = source[1]; 405 destination[2] = source[0]; 406 destination[3] = 0xFF; 407 } 408 409 void unpackARGB8ToRGBA8(const uint8_t* source, uint8_t* destination) 410 { 411 destination[0] = source[1]; 412 destination[1] = source[2]; 413 destination[2] = source[3]; 414 destination[3] = source[0]; 415 } 416 417 void unpackARGB16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 418 { 419 destination[0] = convertColor16LittleTo8(source[1]); 420 destination[1] = convertColor16LittleTo8(source[2]); 421 destination[2] = convertColor16LittleTo8(source[3]); 422 destination[3] = convertColor16LittleTo8(source[0]); 423 } 424 425 void unpackARGB16BigToRGBA8(const uint16_t* source, uint8_t* destination) 426 { 427 destination[0] = convertColor16BigTo8(source[1]); 428 destination[1] = convertColor16BigTo8(source[2]); 429 destination[2] = convertColor16BigTo8(source[3]); 430 destination[3] = convertColor16BigTo8(source[0]); 431 } 432 433 void unpackABGR8ToRGBA8(const uint8_t* source, uint8_t* destination) 434 { 435 destination[0] = source[3]; 436 destination[1] = source[2]; 437 destination[2] = source[1]; 438 destination[3] = source[0]; 439 } 440 441 void unpackBGRA8ToRGBA8(const uint8_t* source, uint8_t* destination) 442 { 443 destination[0] = source[2]; 444 destination[1] = source[1]; 445 destination[2] = source[0]; 446 destination[3] = source[3]; 447 } 448 449 void unpackBGRA16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 450 { 451 destination[0] = convertColor16LittleTo8(source[2]); 452 destination[1] = convertColor16LittleTo8(source[1]); 453 destination[2] = convertColor16LittleTo8(source[0]); 454 destination[3] = convertColor16LittleTo8(source[3]); 455 } 456 457 void unpackBGRA16BigToRGBA8(const uint16_t* source, uint8_t* destination) 458 { 459 destination[0] = convertColor16BigTo8(source[2]); 460 destination[1] = convertColor16BigTo8(source[1]); 461 destination[2] = convertColor16BigTo8(source[0]); 462 destination[3] = convertColor16BigTo8(source[3]); 463 } 464 465 void unpackRGBA5551ToRGBA8(const uint16_t* source, uint8_t* destination) 466 { 467 uint16_t packedValue = source[0]; 468 uint8_t r = packedValue >> 11; 469 uint8_t g = (packedValue >> 6) & 0x1F; 470 uint8_t b = (packedValue >> 1) & 0x1F; 471 destination[0] = (r << 3) | (r & 0x7); 472 destination[1] = (g << 3) | (g & 0x7); 473 destination[2] = (b << 3) | (b & 0x7); 474 destination[3] = (packedValue & 0x1) ? 0xFF : 0x0; 475 } 476 477 void unpackRGBA4444ToRGBA8(const uint16_t* source, uint8_t* destination) 478 { 479 uint16_t packedValue = source[0]; 480 uint8_t r = packedValue >> 12; 481 uint8_t g = (packedValue >> 8) & 0x0F; 482 uint8_t b = (packedValue >> 4) & 0x0F; 483 uint8_t a = packedValue & 0x0F; 484 destination[0] = r << 4 | r; 485 destination[1] = g << 4 | g; 486 destination[2] = b << 4 | b; 487 destination[3] = a << 4 | a; 488 } 489 490 void unpackRGB565ToRGBA8(const uint16_t* source, uint8_t* destination) 491 { 492 uint16_t packedValue = source[0]; 493 uint8_t r = packedValue >> 11; 494 uint8_t g = (packedValue >> 5) & 0x3F; 495 uint8_t b = packedValue & 0x1F; 496 destination[0] = (r << 3) | (r & 0x7); 497 destination[1] = (g << 2) | (g & 0x3); 498 destination[2] = (b << 3) | (b & 0x7); 499 destination[3] = 0xFF; 500 } 501 502 void unpackR8ToRGBA8(const uint8_t* source, uint8_t* destination) 503 { 504 destination[0] = source[0]; 505 destination[1] = source[0]; 506 destination[2] = source[0]; 507 destination[3] = 0xFF; 508 } 509 510 void unpackR16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 511 { 512 destination[0] = convertColor16LittleTo8(source[0]); 513 destination[1] = convertColor16LittleTo8(source[0]); 514 destination[2] = convertColor16LittleTo8(source[0]); 515 destination[3] = 0xFF; 516 } 517 518 void unpackR16BigToRGBA8(const uint16_t* source, uint8_t* destination) 519 { 520 destination[0] = convertColor16BigTo8(source[0]); 521 destination[1] = convertColor16BigTo8(source[0]); 522 destination[2] = convertColor16BigTo8(source[0]); 523 destination[3] = 0xFF; 524 } 525 526 void unpackRA8ToRGBA8(const uint8_t* source, uint8_t* destination) 527 { 528 destination[0] = source[0]; 529 destination[1] = source[0]; 530 destination[2] = source[0]; 531 destination[3] = source[1]; 532 } 533 534 void unpackRA16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 535 { 536 destination[0] = convertColor16LittleTo8(source[0]); 537 destination[1] = convertColor16LittleTo8(source[0]); 538 destination[2] = convertColor16LittleTo8(source[0]); 539 destination[3] = convertColor16LittleTo8(source[1]); 540 } 541 542 void unpackRA16BigToRGBA8(const uint16_t* source, uint8_t* destination) 543 { 544 destination[0] = convertColor16BigTo8(source[0]); 545 destination[1] = convertColor16BigTo8(source[0]); 546 destination[2] = convertColor16BigTo8(source[0]); 547 destination[3] = convertColor16BigTo8(source[1]); 548 } 549 550 void unpackAR8ToRGBA8(const uint8_t* source, uint8_t* destination) 551 { 552 destination[0] = source[1]; 553 destination[1] = source[1]; 554 destination[2] = source[1]; 555 destination[3] = source[0]; 556 } 557 558 void unpackAR16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 559 { 560 destination[0] = convertColor16LittleTo8(source[1]); 561 destination[1] = convertColor16LittleTo8(source[1]); 562 destination[2] = convertColor16LittleTo8(source[1]); 563 destination[3] = convertColor16LittleTo8(source[0]); 564 } 565 566 void unpackAR16BigToRGBA8(const uint16_t* source, uint8_t* destination) 567 { 568 destination[0] = convertColor16BigTo8(source[1]); 569 destination[1] = convertColor16BigTo8(source[1]); 570 destination[2] = convertColor16BigTo8(source[1]); 571 destination[3] = convertColor16BigTo8(source[0]); 572 } 573 574 void unpackA8ToRGBA8(const uint8_t* source, uint8_t* destination) 575 { 576 destination[0] = 0x0; 577 destination[1] = 0x0; 578 destination[2] = 0x0; 579 destination[3] = source[0]; 580 } 581 582 void unpackA16LittleToRGBA8(const uint16_t* source, uint8_t* destination) 583 { 584 destination[0] = 0x0; 585 destination[1] = 0x0; 586 destination[2] = 0x0; 587 destination[3] = convertColor16LittleTo8(source[0]); 588 } 589 590 void unpackA16BigToRGBA8(const uint16_t* source, uint8_t* destination) 591 { 592 destination[0] = 0x0; 593 destination[1] = 0x0; 594 destination[2] = 0x0; 595 destination[3] = convertColor16BigTo8(source[0]); 596 } 597 598 void unpackRGB32FToRGBA32F(const float* source, float* destination) 599 { 600 destination[0] = source[0]; 601 destination[1] = source[1]; 602 destination[2] = source[2]; 603 destination[3] = 1; 604 } 605 606 void unpackR32FToRGBA32F(const float* source, float* destination) 607 { 608 destination[0] = source[0]; 609 destination[1] = source[0]; 610 destination[2] = source[0]; 611 destination[3] = 1; 612 } 613 614 void unpackRA32FToRGBA32F(const float* source, float* destination) 615 { 616 destination[0] = source[0]; 617 destination[1] = source[0]; 618 destination[2] = source[0]; 619 destination[3] = source[1]; 620 } 621 622 void unpackA32FToRGBA32F(const float* source, float* destination) 623 { 624 destination[0] = 0; 625 destination[1] = 0; 626 destination[2] = 0; 627 destination[3] = source[0]; 628 } 629 630 //---------------------------------------------------------------------- 631 // Pixel packing routines. 632 // 633 634 void packRGBA8ToA8(const uint8_t* source, uint8_t* destination) 635 { 636 destination[0] = source[3]; 637 } 638 639 void packRGBA8ToR8(const uint8_t* source, uint8_t* destination) 640 { 641 destination[0] = source[0]; 642 } 643 644 void packRGBA8ToR8Premultiply(const uint8_t* source, uint8_t* destination) 645 { 646 float scaleFactor = source[3] / 255.0f; 647 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 648 destination[0] = sourceR; 649 } 650 651 // FIXME: this routine is lossy and must be removed. 652 void packRGBA8ToR8Unmultiply(const uint8_t* source, uint8_t* destination) 653 { 654 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 655 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 656 destination[0] = sourceR; 657 } 658 659 void packRGBA8ToRA8(const uint8_t* source, uint8_t* destination) 660 { 661 destination[0] = source[0]; 662 destination[1] = source[3]; 663 } 664 665 void packRGBA8ToRA8Premultiply(const uint8_t* source, uint8_t* destination) 666 { 667 float scaleFactor = source[3] / 255.0f; 668 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 669 destination[0] = sourceR; 670 destination[1] = source[3]; 671 } 672 673 // FIXME: this routine is lossy and must be removed. 674 void packRGBA8ToRA8Unmultiply(const uint8_t* source, uint8_t* destination) 675 { 676 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 677 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 678 destination[0] = sourceR; 679 destination[1] = source[3]; 680 } 681 682 void packRGBA8ToRGB8(const uint8_t* source, uint8_t* destination) 683 { 684 destination[0] = source[0]; 685 destination[1] = source[1]; 686 destination[2] = source[2]; 687 } 688 689 void packRGBA8ToRGB8Premultiply(const uint8_t* source, uint8_t* destination) 690 { 691 float scaleFactor = source[3] / 255.0f; 692 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 693 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 694 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 695 destination[0] = sourceR; 696 destination[1] = sourceG; 697 destination[2] = sourceB; 698 } 699 700 // FIXME: this routine is lossy and must be removed. 701 void packRGBA8ToRGB8Unmultiply(const uint8_t* source, uint8_t* destination) 702 { 703 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 704 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 705 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 706 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 707 destination[0] = sourceR; 708 destination[1] = sourceG; 709 destination[2] = sourceB; 710 } 711 712 // This is only used when the source format is different than SourceFormatRGBA8. 713 void packRGBA8ToRGBA8(const uint8_t* source, uint8_t* destination) 714 { 715 destination[0] = source[0]; 716 destination[1] = source[1]; 717 destination[2] = source[2]; 718 destination[3] = source[3]; 719 } 720 721 void packRGBA8ToRGBA8Premultiply(const uint8_t* source, uint8_t* destination) 722 { 723 float scaleFactor = source[3] / 255.0f; 724 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 725 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 726 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 727 destination[0] = sourceR; 728 destination[1] = sourceG; 729 destination[2] = sourceB; 730 destination[3] = source[3]; 731 } 732 733 // FIXME: this routine is lossy and must be removed. 734 void packRGBA8ToRGBA8Unmultiply(const uint8_t* source, uint8_t* destination) 735 { 736 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 737 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 738 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 739 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 740 destination[0] = sourceR; 741 destination[1] = sourceG; 742 destination[2] = sourceB; 743 destination[3] = source[3]; 744 } 745 746 void packRGBA8ToUnsignedShort4444(const uint8_t* source, uint16_t* destination) 747 { 748 *destination = (((source[0] & 0xF0) << 8) 749 | ((source[1] & 0xF0) << 4) 750 | (source[2] & 0xF0) 751 | (source[3] >> 4)); 752 } 753 754 void packRGBA8ToUnsignedShort4444Premultiply(const uint8_t* source, uint16_t* destination) 755 { 756 float scaleFactor = source[3] / 255.0f; 757 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 758 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 759 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 760 *destination = (((sourceR & 0xF0) << 8) 761 | ((sourceG & 0xF0) << 4) 762 | (sourceB & 0xF0) 763 | (source[3] >> 4)); 764 } 765 766 // FIXME: this routine is lossy and must be removed. 767 void packRGBA8ToUnsignedShort4444Unmultiply(const uint8_t* source, uint16_t* destination) 768 { 769 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 770 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 771 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 772 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 773 *destination = (((sourceR & 0xF0) << 8) 774 | ((sourceG & 0xF0) << 4) 775 | (sourceB & 0xF0) 776 | (source[3] >> 4)); 777 } 778 779 void packRGBA8ToUnsignedShort5551(const uint8_t* source, uint16_t* destination) 780 { 781 *destination = (((source[0] & 0xF8) << 8) 782 | ((source[1] & 0xF8) << 3) 783 | ((source[2] & 0xF8) >> 2) 784 | (source[3] >> 7)); 785 } 786 787 void packRGBA8ToUnsignedShort5551Premultiply(const uint8_t* source, uint16_t* destination) 788 { 789 float scaleFactor = source[3] / 255.0f; 790 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 791 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 792 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 793 *destination = (((sourceR & 0xF8) << 8) 794 | ((sourceG & 0xF8) << 3) 795 | ((sourceB & 0xF8) >> 2) 796 | (source[3] >> 7)); 797 } 798 799 // FIXME: this routine is lossy and must be removed. 800 void packRGBA8ToUnsignedShort5551Unmultiply(const uint8_t* source, uint16_t* destination) 801 { 802 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 803 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 804 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 805 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 806 *destination = (((sourceR & 0xF8) << 8) 807 | ((sourceG & 0xF8) << 3) 808 | ((sourceB & 0xF8) >> 2) 809 | (source[3] >> 7)); 810 } 811 812 void packRGBA8ToUnsignedShort565(const uint8_t* source, uint16_t* destination) 813 { 814 *destination = (((source[0] & 0xF8) << 8) 815 | ((source[1] & 0xFC) << 3) 816 | ((source[2] & 0xF8) >> 3)); 817 } 818 819 void packRGBA8ToUnsignedShort565Premultiply(const uint8_t* source, uint16_t* destination) 820 { 821 float scaleFactor = source[3] / 255.0f; 822 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 823 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 824 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 825 *destination = (((sourceR & 0xF8) << 8) 826 | ((sourceG & 0xFC) << 3) 827 | ((sourceB & 0xF8) >> 3)); 828 } 829 830 // FIXME: this routine is lossy and must be removed. 831 void packRGBA8ToUnsignedShort565Unmultiply(const uint8_t* source, uint16_t* destination) 832 { 833 float scaleFactor = 1.0f / (source[3] ? source[3] / 255.0f : 1.0f); 834 uint8_t sourceR = static_cast<uint8_t>(static_cast<float>(source[0]) * scaleFactor); 835 uint8_t sourceG = static_cast<uint8_t>(static_cast<float>(source[1]) * scaleFactor); 836 uint8_t sourceB = static_cast<uint8_t>(static_cast<float>(source[2]) * scaleFactor); 837 *destination = (((sourceR & 0xF8) << 8) 838 | ((sourceG & 0xFC) << 3) 839 | ((sourceB & 0xF8) >> 3)); 840 } 841 842 void packRGBA32FToRGB32F(const float* source, float* destination) 843 { 844 destination[0] = source[0]; 845 destination[1] = source[1]; 846 destination[2] = source[2]; 847 } 848 849 void packRGBA32FToRGB32FPremultiply(const float* source, float* destination) 850 { 851 float scaleFactor = source[3]; 852 destination[0] = source[0] * scaleFactor; 853 destination[1] = source[1] * scaleFactor; 854 destination[2] = source[2] * scaleFactor; 855 } 856 857 void packRGBA32FToRGBA32FPremultiply(const float* source, float* destination) 858 { 859 float scaleFactor = source[3]; 860 destination[0] = source[0] * scaleFactor; 861 destination[1] = source[1] * scaleFactor; 862 destination[2] = source[2] * scaleFactor; 863 destination[3] = source[3]; 864 } 865 866 void packRGBA32FToA32F(const float* source, float* destination) 867 { 868 destination[0] = source[3]; 869 } 870 871 void packRGBA32FToR32F(const float* source, float* destination) 872 { 873 destination[0] = source[0]; 874 } 875 876 void packRGBA32FToR32FPremultiply(const float* source, float* destination) 877 { 878 float scaleFactor = source[3]; 879 destination[0] = source[0] * scaleFactor; 880 } 881 882 883 void packRGBA32FToRA32F(const float* source, float* destination) 884 { 885 destination[0] = source[0]; 886 destination[1] = source[3]; 887 } 888 889 void packRGBA32FToRA32FPremultiply(const float* source, float* destination) 890 { 891 float scaleFactor = source[3]; 892 destination[0] = source[0] * scaleFactor; 893 destination[1] = scaleFactor; 894 } 895 896 } // anonymous namespace 897 898 // This is used whenever unpacking is necessary; i.e., the source data 899 // is not in RGBA8/RGBA32F format, or the unpack alignment specifies 900 // that rows are not tightly packed. 901 template<typename SourceType, typename IntermediateType, typename DestType, 902 void unpackingFunc(const SourceType*, IntermediateType*), 903 void packingFunc(const IntermediateType*, DestType*)> 904 static void doUnpackingAndPacking(const SourceType* sourceData, 905 unsigned int width, 906 unsigned int height, 907 unsigned int sourceElementsPerPixel, 908 unsigned int sourceElementsPerRow, 909 DestType* destinationData, 910 unsigned int destinationElementsPerPixel) 911 { 912 if (!sourceElementsPerRow) { 913 unsigned int numElements = width * height * sourceElementsPerPixel; 914 const SourceType* endPointer = sourceData + numElements; 915 IntermediateType temporaryRGBAData[4]; 916 while (sourceData < endPointer) { 917 unpackingFunc(sourceData, temporaryRGBAData); 918 packingFunc(temporaryRGBAData, destinationData); 919 sourceData += sourceElementsPerPixel; 920 destinationData += destinationElementsPerPixel; 921 } 922 } else { 923 IntermediateType temporaryRGBAData[4]; 924 for (unsigned int y = 0; y < height; ++y) { 925 const SourceType* currentSource = sourceData; 926 for (unsigned int x = 0; x < width; ++x) { 927 unpackingFunc(currentSource, temporaryRGBAData); 928 packingFunc(temporaryRGBAData, destinationData); 929 currentSource += sourceElementsPerPixel; 930 destinationData += destinationElementsPerPixel; 931 } 932 sourceData += sourceElementsPerRow; 933 } 934 } 935 } 936 937 template<typename SourceType> 938 static void computeIncrementParameters(unsigned int width, 939 unsigned int bytesPerPixel, 940 unsigned int unpackAlignment, 941 unsigned int* sourceElementsPerPixel, 942 unsigned int* sourceElementsPerRow) 943 { 944 unsigned int elementSizeInBytes = sizeof(SourceType); 945 ASSERT(elementSizeInBytes <= bytesPerPixel); 946 ASSERT(!(bytesPerPixel % elementSizeInBytes)); 947 unsigned int validRowBytes = width * bytesPerPixel; 948 unsigned int totalRowBytes = validRowBytes; 949 if (unpackAlignment) { 950 unsigned int remainder = validRowBytes % unpackAlignment; 951 if (remainder) 952 totalRowBytes += (unpackAlignment - remainder); 953 } 954 *sourceElementsPerPixel = bytesPerPixel / elementSizeInBytes; 955 if (validRowBytes == totalRowBytes) 956 *sourceElementsPerRow = 0; 957 else 958 *sourceElementsPerRow = totalRowBytes / elementSizeInBytes; 959 } 960 961 // This handles all conversions with a faster path for tightly packed RGBA8 source data. 962 template<typename DestType, void packingFunc(const uint8_t*, DestType*)> 963 static void doPacking(const void* sourceData, 964 GraphicsContext3D::SourceDataFormat sourceDataFormat, 965 unsigned int width, 966 unsigned int height, 967 unsigned int sourceUnpackAlignment, 968 DestType* destinationData, 969 unsigned int destinationElementsPerPixel) 970 { 971 switch (sourceDataFormat) { 972 case GraphicsContext3D::SourceFormatRGBA8: { 973 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 974 computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 975 if (!sourceElementsPerRow) { 976 const uint8_t* source = static_cast<const uint8_t*>(sourceData); 977 unsigned int numElements = width * height * 4; 978 const uint8_t* endPointer = source + numElements; 979 while (source < endPointer) { 980 packingFunc(source, destinationData); 981 source += sourceElementsPerPixel; 982 destinationData += destinationElementsPerPixel; 983 } 984 } else { 985 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackRGBA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 986 } 987 break; 988 } 989 case GraphicsContext3D::SourceFormatRGBA16Little: { 990 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 991 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 992 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGBA16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 993 break; 994 } 995 case GraphicsContext3D::SourceFormatRGBA16Big: { 996 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 997 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 998 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGBA16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 999 break; 1000 } 1001 case GraphicsContext3D::SourceFormatRGB8: { 1002 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1003 computeIncrementParameters<uint8_t>(width, 3, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1004 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackRGB8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1005 break; 1006 } 1007 case GraphicsContext3D::SourceFormatRGB16Little: { 1008 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1009 computeIncrementParameters<uint16_t>(width, 6, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1010 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGB16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1011 break; 1012 } 1013 case GraphicsContext3D::SourceFormatRGB16Big: { 1014 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1015 computeIncrementParameters<uint16_t>(width, 6, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1016 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGB16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1017 break; 1018 } 1019 case GraphicsContext3D::SourceFormatBGR8: { 1020 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1021 computeIncrementParameters<uint8_t>(width, 3, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1022 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackBGR8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1023 break; 1024 } 1025 case GraphicsContext3D::SourceFormatARGB8: { 1026 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1027 computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1028 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackARGB8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1029 break; 1030 } 1031 case GraphicsContext3D::SourceFormatARGB16Little: { 1032 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1033 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1034 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackARGB16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1035 break; 1036 } 1037 case GraphicsContext3D::SourceFormatARGB16Big: { 1038 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1039 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1040 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackARGB16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1041 break; 1042 } 1043 case GraphicsContext3D::SourceFormatABGR8: { 1044 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1045 computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1046 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackABGR8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1047 break; 1048 } 1049 case GraphicsContext3D::SourceFormatBGRA8: { 1050 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1051 computeIncrementParameters<uint8_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1052 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackBGRA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1053 break; 1054 } 1055 case GraphicsContext3D::SourceFormatBGRA16Little: { 1056 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1057 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1058 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackBGRA16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1059 break; 1060 } 1061 case GraphicsContext3D::SourceFormatBGRA16Big: { 1062 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1063 computeIncrementParameters<uint16_t>(width, 8, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1064 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackBGRA16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1065 break; 1066 } 1067 case GraphicsContext3D::SourceFormatRGBA5551: { 1068 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1069 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1070 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGBA5551ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1071 break; 1072 } 1073 case GraphicsContext3D::SourceFormatRGBA4444: { 1074 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1075 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1076 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGBA4444ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1077 break; 1078 } 1079 case GraphicsContext3D::SourceFormatRGB565: { 1080 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1081 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1082 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRGB565ToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1083 break; 1084 } 1085 case GraphicsContext3D::SourceFormatR8: { 1086 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1087 computeIncrementParameters<uint8_t>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1088 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackR8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1089 break; 1090 } 1091 case GraphicsContext3D::SourceFormatR16Little: { 1092 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1093 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1094 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackR16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1095 break; 1096 } 1097 case GraphicsContext3D::SourceFormatR16Big: { 1098 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1099 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1100 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackR16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1101 break; 1102 } 1103 case GraphicsContext3D::SourceFormatRA8: { 1104 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1105 computeIncrementParameters<uint8_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1106 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackRA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1107 break; 1108 } 1109 case GraphicsContext3D::SourceFormatRA16Little: { 1110 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1111 computeIncrementParameters<uint16_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1112 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRA16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1113 break; 1114 } 1115 case GraphicsContext3D::SourceFormatRA16Big: { 1116 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1117 computeIncrementParameters<uint16_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1118 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackRA16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1119 break; 1120 } 1121 case GraphicsContext3D::SourceFormatAR8: { 1122 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1123 computeIncrementParameters<uint8_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1124 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackAR8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1125 break; 1126 } 1127 case GraphicsContext3D::SourceFormatAR16Little: { 1128 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1129 computeIncrementParameters<uint16_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1130 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackAR16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1131 break; 1132 } 1133 case GraphicsContext3D::SourceFormatAR16Big: { 1134 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1135 computeIncrementParameters<uint16_t>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1136 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackAR16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1137 break; 1138 } 1139 case GraphicsContext3D::SourceFormatA8: { 1140 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1141 computeIncrementParameters<uint8_t>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1142 doUnpackingAndPacking<uint8_t, uint8_t, DestType, unpackA8ToRGBA8, packingFunc>(static_cast<const uint8_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1143 break; 1144 } 1145 case GraphicsContext3D::SourceFormatA16Little: { 1146 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1147 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1148 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackA16LittleToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1149 break; 1150 } 1151 case GraphicsContext3D::SourceFormatA16Big: { 1152 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1153 computeIncrementParameters<uint16_t>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1154 doUnpackingAndPacking<uint16_t, uint8_t, DestType, unpackA16BigToRGBA8, packingFunc>(static_cast<const uint16_t*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1155 break; 1156 } 1157 default: 1158 ASSERT(false); 1159 } 1160 } 1161 1162 // This specialized routine is used only for floating-point texture uploads. It 1163 // does not need to be as general as doPacking, above; because there are 1164 // currently no native floating-point image formats in WebKit, there are only a 1165 // few upload paths. 1166 template<void packingFunc(const float*, float*)> 1167 static void doFloatingPointPacking(const void* sourceData, 1168 GraphicsContext3D::SourceDataFormat sourceDataFormat, 1169 unsigned int width, 1170 unsigned int height, 1171 unsigned int sourceUnpackAlignment, 1172 float* destinationData, 1173 unsigned int destinationElementsPerPixel) 1174 { 1175 switch (sourceDataFormat) { 1176 case GraphicsContext3D::SourceFormatRGBA8: { 1177 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1178 computeIncrementParameters<float>(width, 4, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1179 ASSERT(!sourceElementsPerRow); // Guaranteed because each color channel is sizeof(float) bytes. 1180 const float* source = static_cast<const float*>(sourceData); 1181 unsigned int numElements = width * height * 4; 1182 const float* endPointer = source + numElements; 1183 while (source < endPointer) { 1184 packingFunc(source, destinationData); 1185 source += sourceElementsPerPixel; 1186 destinationData += destinationElementsPerPixel; 1187 } 1188 break; 1189 } 1190 case GraphicsContext3D::SourceFormatRGB32F: { 1191 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1192 computeIncrementParameters<float>(width, 3, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1193 doUnpackingAndPacking<float, float, float, unpackRGB32FToRGBA32F, packingFunc>(static_cast<const float*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1194 break; 1195 } 1196 case GraphicsContext3D::SourceFormatR32F: { 1197 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1198 computeIncrementParameters<float>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1199 doUnpackingAndPacking<float, float, float, unpackR32FToRGBA32F, packingFunc>(static_cast<const float*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1200 break; 1201 } 1202 case GraphicsContext3D::SourceFormatRA32F: { 1203 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1204 computeIncrementParameters<float>(width, 2, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1205 doUnpackingAndPacking<float, float, float, unpackRA32FToRGBA32F, packingFunc>(static_cast<const float*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1206 break; 1207 } 1208 case GraphicsContext3D::SourceFormatA32F: { 1209 unsigned int sourceElementsPerPixel, sourceElementsPerRow; 1210 computeIncrementParameters<float>(width, 1, sourceUnpackAlignment, &sourceElementsPerPixel, &sourceElementsPerRow); 1211 doUnpackingAndPacking<float, float, float, unpackA32FToRGBA32F, packingFunc>(static_cast<const float*>(sourceData), width, height, sourceElementsPerPixel, sourceElementsPerRow, destinationData, destinationElementsPerPixel); 1212 break; 1213 } 1214 default: 1215 ASSERT_NOT_REACHED(); 1216 } 1217 } 1218 1219 bool GraphicsContext3D::packPixels(const uint8_t* sourceData, 1220 GraphicsContext3D::SourceDataFormat sourceDataFormat, 1221 unsigned int width, 1222 unsigned int height, 1223 unsigned int sourceUnpackAlignment, 1224 unsigned int destinationFormat, 1225 unsigned int destinationType, 1226 AlphaOp alphaOp, 1227 void* destinationData) 1228 { 1229 switch (destinationType) { 1230 case UNSIGNED_BYTE: { 1231 uint8_t* destination = static_cast<uint8_t*>(destinationData); 1232 if (sourceDataFormat == SourceFormatRGBA8 && destinationFormat == RGBA && sourceUnpackAlignment <= 4 && alphaOp == AlphaDoNothing) { 1233 // No conversion necessary. 1234 memcpy(destinationData, sourceData, width * height * 4); 1235 break; 1236 } 1237 switch (destinationFormat) { 1238 case RGB: 1239 switch (alphaOp) { 1240 case AlphaDoNothing: 1241 doPacking<uint8_t, packRGBA8ToRGB8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3); 1242 break; 1243 case AlphaDoPremultiply: 1244 doPacking<uint8_t, packRGBA8ToRGB8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3); 1245 break; 1246 case AlphaDoUnmultiply: 1247 doPacking<uint8_t, packRGBA8ToRGB8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3); 1248 break; 1249 } 1250 break; 1251 case RGBA: 1252 switch (alphaOp) { 1253 case AlphaDoNothing: 1254 ASSERT(sourceDataFormat != SourceFormatRGBA8 || sourceUnpackAlignment > 4); // Handled above with fast case. 1255 doPacking<uint8_t, packRGBA8ToRGBA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4); 1256 break; 1257 case AlphaDoPremultiply: 1258 doPacking<uint8_t, packRGBA8ToRGBA8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4); 1259 break; 1260 case AlphaDoUnmultiply: 1261 doPacking<uint8_t, packRGBA8ToRGBA8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4); 1262 break; 1263 default: 1264 ASSERT_NOT_REACHED(); 1265 } 1266 break; 1267 case ALPHA: 1268 // From the desktop OpenGL conversion rules (OpenGL 2.1 1269 // specification, Table 3.15), the alpha channel is chosen 1270 // from the RGBA data. 1271 doPacking<uint8_t, packRGBA8ToA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1272 break; 1273 case LUMINANCE: 1274 // From the desktop OpenGL conversion rules (OpenGL 2.1 1275 // specification, Table 3.15), the red channel is chosen 1276 // from the RGBA data. 1277 switch (alphaOp) { 1278 case AlphaDoNothing: 1279 doPacking<uint8_t, packRGBA8ToR8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1280 break; 1281 case AlphaDoPremultiply: 1282 doPacking<uint8_t, packRGBA8ToR8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1283 break; 1284 case AlphaDoUnmultiply: 1285 doPacking<uint8_t, packRGBA8ToR8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1286 break; 1287 } 1288 break; 1289 case LUMINANCE_ALPHA: 1290 // From the desktop OpenGL conversion rules (OpenGL 2.1 1291 // specification, Table 3.15), the red and alpha channels 1292 // are chosen from the RGBA data. 1293 switch (alphaOp) { 1294 case AlphaDoNothing: 1295 doPacking<uint8_t, packRGBA8ToRA8>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2); 1296 break; 1297 case AlphaDoPremultiply: 1298 doPacking<uint8_t, packRGBA8ToRA8Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2); 1299 break; 1300 case AlphaDoUnmultiply: 1301 doPacking<uint8_t, packRGBA8ToRA8Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2); 1302 break; 1303 } 1304 break; 1305 } 1306 break; 1307 } 1308 case UNSIGNED_SHORT_4_4_4_4: { 1309 uint16_t* destination = static_cast<uint16_t*>(destinationData); 1310 switch (alphaOp) { 1311 case AlphaDoNothing: 1312 doPacking<uint16_t, packRGBA8ToUnsignedShort4444>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1313 break; 1314 case AlphaDoPremultiply: 1315 doPacking<uint16_t, packRGBA8ToUnsignedShort4444Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1316 break; 1317 case AlphaDoUnmultiply: 1318 doPacking<uint16_t, packRGBA8ToUnsignedShort4444Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1319 break; 1320 } 1321 break; 1322 } 1323 case UNSIGNED_SHORT_5_5_5_1: { 1324 uint16_t* destination = static_cast<uint16_t*>(destinationData); 1325 switch (alphaOp) { 1326 case AlphaDoNothing: 1327 doPacking<uint16_t, packRGBA8ToUnsignedShort5551>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1328 break; 1329 case AlphaDoPremultiply: 1330 doPacking<uint16_t, packRGBA8ToUnsignedShort5551Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1331 break; 1332 case AlphaDoUnmultiply: 1333 doPacking<uint16_t, packRGBA8ToUnsignedShort5551Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1334 break; 1335 } 1336 break; 1337 } 1338 case UNSIGNED_SHORT_5_6_5: { 1339 uint16_t* destination = static_cast<uint16_t*>(destinationData); 1340 switch (alphaOp) { 1341 case AlphaDoNothing: 1342 doPacking<uint16_t, packRGBA8ToUnsignedShort565>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1343 break; 1344 case AlphaDoPremultiply: 1345 doPacking<uint16_t, packRGBA8ToUnsignedShort565Premultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1346 break; 1347 case AlphaDoUnmultiply: 1348 doPacking<uint16_t, packRGBA8ToUnsignedShort565Unmultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1349 break; 1350 } 1351 break; 1352 } 1353 case FLOAT: { 1354 // OpenGL ES, and therefore WebGL, require that the format and 1355 // internalformat be identical, which implies that the source and 1356 // destination formats will both be floating-point in this branch -- at 1357 // least, until WebKit supports floating-point image formats natively. 1358 ASSERT(sourceDataFormat == SourceFormatRGBA32F || sourceDataFormat == SourceFormatRGB32F 1359 || sourceDataFormat == SourceFormatRA32F || sourceDataFormat == SourceFormatR32F 1360 || sourceDataFormat == SourceFormatA32F); 1361 // Because WebKit doesn't use floating-point color channels for anything 1362 // internally, there's no chance we have to do a (lossy) unmultiply 1363 // operation. 1364 ASSERT(alphaOp == AlphaDoNothing || alphaOp == AlphaDoPremultiply); 1365 // For the source formats with an even number of channels (RGBA32F, 1366 // RA32F) it is guaranteed that the pixel data is tightly packed because 1367 // unpack alignment <= sizeof(float) * number of channels. 1368 float* destination = static_cast<float*>(destinationData); 1369 if (alphaOp == AlphaDoNothing 1370 && ((sourceDataFormat == SourceFormatRGBA32F && destinationFormat == RGBA) 1371 || (sourceDataFormat == SourceFormatRA32F && destinationFormat == LUMINANCE_ALPHA))) { 1372 // No conversion necessary. 1373 int numChannels = (sourceDataFormat == SourceFormatRGBA32F ? 4 : 2); 1374 memcpy(destinationData, sourceData, width * height * numChannels * sizeof(float)); 1375 break; 1376 } 1377 switch (destinationFormat) { 1378 case RGB: 1379 switch (alphaOp) { 1380 case AlphaDoNothing: 1381 doFloatingPointPacking<packRGBA32FToRGB32F>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3); 1382 break; 1383 case AlphaDoPremultiply: 1384 doFloatingPointPacking<packRGBA32FToRGB32FPremultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 3); 1385 break; 1386 default: 1387 ASSERT_NOT_REACHED(); 1388 } 1389 break; 1390 case RGBA: 1391 // AlphaDoNothing is handled above with fast path. 1392 ASSERT(alphaOp == AlphaDoPremultiply); 1393 doFloatingPointPacking<packRGBA32FToRGBA32FPremultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 4); 1394 break; 1395 case ALPHA: 1396 // From the desktop OpenGL conversion rules (OpenGL 2.1 1397 // specification, Table 3.15), the alpha channel is chosen 1398 // from the RGBA data. 1399 doFloatingPointPacking<packRGBA32FToA32F>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1400 break; 1401 case LUMINANCE: 1402 // From the desktop OpenGL conversion rules (OpenGL 2.1 1403 // specification, Table 3.15), the red channel is chosen 1404 // from the RGBA data. 1405 switch (alphaOp) { 1406 case AlphaDoNothing: 1407 doFloatingPointPacking<packRGBA32FToR32F>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1408 break; 1409 case AlphaDoPremultiply: 1410 doFloatingPointPacking<packRGBA32FToR32FPremultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 1); 1411 break; 1412 default: 1413 ASSERT_NOT_REACHED(); 1414 } 1415 break; 1416 case LUMINANCE_ALPHA: 1417 // From the desktop OpenGL conversion rules (OpenGL 2.1 1418 // specification, Table 3.15), the red and alpha channels 1419 // are chosen from the RGBA data. 1420 switch (alphaOp) { 1421 case AlphaDoNothing: 1422 doFloatingPointPacking<packRGBA32FToRA32F>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2); 1423 break; 1424 case AlphaDoPremultiply: 1425 doFloatingPointPacking<packRGBA32FToRA32FPremultiply>(sourceData, sourceDataFormat, width, height, sourceUnpackAlignment, destination, 2); 1426 break; 1427 default: 1428 ASSERT_NOT_REACHED(); 1429 } 1430 break; 1431 } 1432 break; 1433 } 1434 } 1435 return true; 1436 } 1437 1438 } // namespace WebCore 1439 1440 #endif // ENABLE(WEBGL) 1441
