1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "Image.hpp" 16 17 #include "../libEGL/Context.hpp" 18 #include "../libEGL/Texture.hpp" 19 #include "../common/debug.h" 20 #include "Common/Math.hpp" 21 #include "Common/Thread.hpp" 22 23 #include <GLES3/gl3.h> 24 25 #include <string.h> 26 27 namespace 28 { 29 int getNumBlocks(int w, int h, int blockSizeX, int blockSizeY) 30 { 31 return ((w + blockSizeX - 1) / blockSizeX) * ((h + blockSizeY - 1) / blockSizeY); 32 } 33 34 enum DataType 35 { 36 Bytes_1, 37 Bytes_2, 38 Bytes_4, 39 Bytes_8, 40 Bytes_16, 41 ByteRGB, 42 UByteRGB, 43 ShortRGB, 44 UShortRGB, 45 IntRGB, 46 UIntRGB, 47 RGB565, 48 FloatRGB, 49 HalfFloatRGB, 50 RGBA4444, 51 RGBA5551, 52 RGB10A2UI, 53 R11G11B10F, 54 RGB9E5, 55 SRGB, 56 SRGBA, 57 D16, 58 D24, 59 D32, 60 D32F, 61 S8, 62 S24_8, 63 }; 64 65 template<DataType dataType> 66 void LoadImageRow(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 67 { 68 UNIMPLEMENTED(); 69 } 70 71 template<> 72 void LoadImageRow<Bytes_1>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 73 { 74 memcpy(dest + xoffset, source, width); 75 } 76 77 template<> 78 void LoadImageRow<Bytes_2>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 79 { 80 memcpy(dest + xoffset * 2, source, width * 2); 81 } 82 83 template<> 84 void LoadImageRow<Bytes_4>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 85 { 86 memcpy(dest + xoffset * 4, source, width * 4); 87 } 88 89 template<> 90 void LoadImageRow<Bytes_8>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 91 { 92 memcpy(dest + xoffset * 8, source, width * 8); 93 } 94 95 template<> 96 void LoadImageRow<Bytes_16>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 97 { 98 memcpy(dest + xoffset * 16, source, width * 16); 99 } 100 101 template<> 102 void LoadImageRow<ByteRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 103 { 104 unsigned char *destB = dest + xoffset * 4; 105 106 for(int x = 0; x < width; x++) 107 { 108 destB[4 * x + 0] = source[x * 3 + 0]; 109 destB[4 * x + 1] = source[x * 3 + 1]; 110 destB[4 * x + 2] = source[x * 3 + 2]; 111 destB[4 * x + 3] = 0x7F; 112 } 113 } 114 115 template<> 116 void LoadImageRow<UByteRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 117 { 118 unsigned char *destB = dest + xoffset * 4; 119 120 for(int x = 0; x < width; x++) 121 { 122 destB[4 * x + 0] = source[x * 3 + 0]; 123 destB[4 * x + 1] = source[x * 3 + 1]; 124 destB[4 * x + 2] = source[x * 3 + 2]; 125 destB[4 * x + 3] = 0xFF; 126 } 127 } 128 129 template<> 130 void LoadImageRow<ShortRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 131 { 132 const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source); 133 unsigned short *destS = reinterpret_cast<unsigned short*>(dest + xoffset * 8); 134 135 for(int x = 0; x < width; x++) 136 { 137 destS[4 * x + 0] = sourceS[x * 3 + 0]; 138 destS[4 * x + 1] = sourceS[x * 3 + 1]; 139 destS[4 * x + 2] = sourceS[x * 3 + 2]; 140 destS[4 * x + 3] = 0x7FFF; 141 } 142 } 143 144 template<> 145 void LoadImageRow<UShortRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 146 { 147 const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source); 148 unsigned short *destS = reinterpret_cast<unsigned short*>(dest + xoffset * 8); 149 150 for(int x = 0; x < width; x++) 151 { 152 destS[4 * x + 0] = sourceS[x * 3 + 0]; 153 destS[4 * x + 1] = sourceS[x * 3 + 1]; 154 destS[4 * x + 2] = sourceS[x * 3 + 2]; 155 destS[4 * x + 3] = 0xFFFF; 156 } 157 } 158 159 template<> 160 void LoadImageRow<IntRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 161 { 162 const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source); 163 unsigned int *destI = reinterpret_cast<unsigned int*>(dest + xoffset * 16); 164 165 for(int x = 0; x < width; x++) 166 { 167 destI[4 * x + 0] = sourceI[x * 3 + 0]; 168 destI[4 * x + 1] = sourceI[x * 3 + 1]; 169 destI[4 * x + 2] = sourceI[x * 3 + 2]; 170 destI[4 * x + 3] = 0x7FFFFFFF; 171 } 172 } 173 174 template<> 175 void LoadImageRow<UIntRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 176 { 177 const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source); 178 unsigned int *destI = reinterpret_cast<unsigned int*>(dest + xoffset * 16); 179 180 for(int x = 0; x < width; x++) 181 { 182 destI[4 * x + 0] = sourceI[x * 3 + 0]; 183 destI[4 * x + 1] = sourceI[x * 3 + 1]; 184 destI[4 * x + 2] = sourceI[x * 3 + 2]; 185 destI[4 * x + 3] = 0xFFFFFFFF; 186 } 187 } 188 189 template<> 190 void LoadImageRow<RGB565>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 191 { 192 memcpy(dest + xoffset * 2, source, width * 2); 193 } 194 195 template<> 196 void LoadImageRow<FloatRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 197 { 198 const float *sourceF = reinterpret_cast<const float*>(source); 199 float *destF = reinterpret_cast<float*>(dest + xoffset * 16); 200 201 for(int x = 0; x < width; x++) 202 { 203 destF[4 * x + 0] = sourceF[x * 3 + 0]; 204 destF[4 * x + 1] = sourceF[x * 3 + 1]; 205 destF[4 * x + 2] = sourceF[x * 3 + 2]; 206 destF[4 * x + 3] = 1.0f; 207 } 208 } 209 210 template<> 211 void LoadImageRow<HalfFloatRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 212 { 213 const unsigned short *sourceH = reinterpret_cast<const unsigned short*>(source); 214 unsigned short *destH = reinterpret_cast<unsigned short*>(dest + xoffset * 8); 215 216 for(int x = 0; x < width; x++) 217 { 218 destH[4 * x + 0] = sourceH[x * 3 + 0]; 219 destH[4 * x + 1] = sourceH[x * 3 + 1]; 220 destH[4 * x + 2] = sourceH[x * 3 + 2]; 221 destH[4 * x + 3] = 0x3C00; // SEEEEEMMMMMMMMMM, S = 0, E = 15, M = 0: 16bit flpt representation of 1 222 } 223 } 224 225 template<> 226 void LoadImageRow<RGBA4444>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 227 { 228 const unsigned short *source4444 = reinterpret_cast<const unsigned short*>(source); 229 unsigned char *dest4444 = dest + xoffset * 4; 230 231 for(int x = 0; x < width; x++) 232 { 233 unsigned short rgba = source4444[x]; 234 dest4444[4 * x + 0] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4); 235 dest4444[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8); 236 dest4444[4 * x + 2] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12); 237 dest4444[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0); 238 } 239 } 240 241 template<> 242 void LoadImageRow<RGBA5551>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 243 { 244 const unsigned short *source5551 = reinterpret_cast<const unsigned short*>(source); 245 unsigned char *dest5551 = dest + xoffset * 4; 246 247 for(int x = 0; x < width; x++) 248 { 249 unsigned short rgba = source5551[x]; 250 dest5551[4 * x + 0] = ((rgba & 0x003E) << 2) | ((rgba & 0x003E) >> 3); 251 dest5551[4 * x + 1] = ((rgba & 0x07C0) >> 3) | ((rgba & 0x07C0) >> 8); 252 dest5551[4 * x + 2] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13); 253 dest5551[4 * x + 3] = (rgba & 0x0001) ? 0xFF : 0; 254 } 255 } 256 257 template<> 258 void LoadImageRow<RGB10A2UI>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 259 { 260 const unsigned int *source1010102U = reinterpret_cast<const unsigned int*>(source); 261 unsigned short *dest16U = reinterpret_cast<unsigned short*>(dest + xoffset * 8); 262 263 for(int x = 0; x < width; x++) 264 { 265 unsigned int rgba = source1010102U[x]; 266 dest16U[4 * x + 0] = (rgba & 0x000003FF); 267 dest16U[4 * x + 1] = (rgba & 0x000FFC00) >> 10; 268 dest16U[4 * x + 2] = (rgba & 0x3FF00000) >> 20; 269 dest16U[4 * x + 3] = (rgba & 0xC0000000) >> 30; 270 } 271 } 272 273 template<> 274 void LoadImageRow<R11G11B10F>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 275 { 276 const sw::R11G11B10FData *sourceRGB = reinterpret_cast<const sw::R11G11B10FData*>(source); 277 float *destF = reinterpret_cast<float*>(dest + xoffset * 16); 278 279 for(int x = 0; x < width; x++, sourceRGB++, destF+=4) 280 { 281 sourceRGB->toRGBFloats(destF); 282 destF[3] = 1.0f; 283 } 284 } 285 286 template<> 287 void LoadImageRow<RGB9E5>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 288 { 289 const sw::RGB9E5Data *sourceRGB = reinterpret_cast<const sw::RGB9E5Data*>(source); 290 float *destF = reinterpret_cast<float*>(dest + xoffset * 16); 291 292 for(int x = 0; x < width; x++, sourceRGB++, destF += 4) 293 { 294 sourceRGB->toRGBFloats(destF); 295 destF[3] = 1.0f; 296 } 297 } 298 299 template<> 300 void LoadImageRow<SRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 301 { 302 dest += xoffset * 4; 303 304 for(int x = 0; x < width; x++) 305 { 306 for(int rgb = 0; rgb < 3; ++rgb) 307 { 308 *dest++ = sw::sRGB8toLinear8(*source++); 309 } 310 *dest++ = 255; 311 } 312 } 313 314 template<> 315 void LoadImageRow<SRGBA>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 316 { 317 dest += xoffset * 4; 318 319 for(int x = 0; x < width; x++) 320 { 321 for(int rgb = 0; rgb < 3; ++rgb) 322 { 323 *dest++ = sw::sRGB8toLinear8(*source++); 324 } 325 *dest++ = *source++; 326 } 327 } 328 329 template<> 330 void LoadImageRow<D16>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 331 { 332 const unsigned short *sourceD16 = reinterpret_cast<const unsigned short*>(source); 333 float *destF = reinterpret_cast<float*>(dest + xoffset * 4); 334 335 for(int x = 0; x < width; x++) 336 { 337 destF[x] = (float)sourceD16[x] / 0xFFFF; 338 } 339 } 340 341 template<> 342 void LoadImageRow<D24>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 343 { 344 const unsigned int *sourceD24 = reinterpret_cast<const unsigned int*>(source); 345 float *destF = reinterpret_cast<float*>(dest + xoffset * 4); 346 347 for(int x = 0; x < width; x++) 348 { 349 destF[x] = (float)(sourceD24[x] & 0xFFFFFF00) / 0xFFFFFF00; 350 } 351 } 352 353 template<> 354 void LoadImageRow<D32>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 355 { 356 const unsigned int *sourceD32 = reinterpret_cast<const unsigned int*>(source); 357 float *destF = reinterpret_cast<float*>(dest + xoffset * 4); 358 359 for(int x = 0; x < width; x++) 360 { 361 destF[x] = (float)sourceD32[x] / 0xFFFFFFFF; 362 } 363 } 364 365 template<> 366 void LoadImageRow<S8>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 367 { 368 const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source); 369 unsigned char *destI = dest + xoffset; 370 371 for(int x = 0; x < width; x++) 372 { 373 destI[x] = static_cast<unsigned char>(sourceI[x] & 0x000000FF); // FIXME: Quad layout 374 } 375 } 376 377 template<> 378 void LoadImageRow<D32F>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 379 { 380 struct D32FS8 { float depth32f; unsigned int stencil24_8; }; 381 const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source); 382 float *destF = reinterpret_cast<float*>(dest + xoffset * 4); 383 384 for(int x = 0; x < width; x++) 385 { 386 destF[x] = sourceD32FS8[x].depth32f; 387 } 388 } 389 390 template<> 391 void LoadImageRow<S24_8>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width) 392 { 393 struct D32FS8 { float depth32f; unsigned int stencil24_8; }; 394 const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source); 395 unsigned char *destI = dest + xoffset; 396 397 for(int x = 0; x < width; x++) 398 { 399 destI[x] = static_cast<unsigned char>(sourceD32FS8[x].stencil24_8 & 0x000000FF); // FIXME: Quad layout 400 } 401 } 402 403 template<DataType dataType> 404 void LoadImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, int destPitch, GLsizei destHeight, const void *input, void *buffer) 405 { 406 for(int z = 0; z < depth; ++z) 407 { 408 const unsigned char *inputStart = static_cast<const unsigned char*>(input) + (z * inputPitch * inputHeight); 409 unsigned char *destStart = static_cast<unsigned char*>(buffer) + ((zoffset + z) * destPitch * destHeight); 410 for(int y = 0; y < height; ++y) 411 { 412 const unsigned char *source = inputStart + y * inputPitch; 413 unsigned char *dest = destStart + (y + yoffset) * destPitch; 414 415 LoadImageRow<dataType>(source, dest, xoffset, width); 416 } 417 } 418 } 419 } 420 421 namespace egl 422 { 423 sw::Format ConvertFormatType(GLenum format, GLenum type) 424 { 425 switch(format) 426 { 427 case GL_LUMINANCE: 428 switch(type) 429 { 430 case GL_UNSIGNED_BYTE: return sw::FORMAT_L8; 431 case GL_HALF_FLOAT: return sw::FORMAT_L16F; 432 case GL_HALF_FLOAT_OES: return sw::FORMAT_L16F; 433 case GL_FLOAT: return sw::FORMAT_L32F; 434 default: UNREACHABLE(type); 435 } 436 break; 437 case GL_LUMINANCE8_EXT: 438 return sw::FORMAT_L8; 439 case GL_LUMINANCE16F_EXT: 440 return sw::FORMAT_L16F; 441 case GL_LUMINANCE32F_EXT: 442 return sw::FORMAT_L32F; 443 case GL_LUMINANCE_ALPHA: 444 switch(type) 445 { 446 case GL_UNSIGNED_BYTE: return sw::FORMAT_A8L8; 447 case GL_HALF_FLOAT: return sw::FORMAT_A16L16F; 448 case GL_HALF_FLOAT_OES: return sw::FORMAT_A16L16F; 449 case GL_FLOAT: return sw::FORMAT_A32L32F; 450 default: UNREACHABLE(type); 451 } 452 break; 453 case GL_LUMINANCE8_ALPHA8_EXT: 454 return sw::FORMAT_A8L8; 455 case GL_LUMINANCE_ALPHA16F_EXT: 456 return sw::FORMAT_A16L16F; 457 case GL_LUMINANCE_ALPHA32F_EXT: 458 return sw::FORMAT_A32L32F; 459 case GL_RGBA: 460 switch(type) 461 { 462 case GL_UNSIGNED_BYTE: return sw::FORMAT_A8B8G8R8; 463 case GL_UNSIGNED_SHORT_4_4_4_4: return sw::FORMAT_R4G4B4A4; 464 case GL_UNSIGNED_SHORT_5_5_5_1: return sw::FORMAT_R5G5B5A1; 465 case GL_HALF_FLOAT: return sw::FORMAT_A16B16G16R16F; 466 case GL_HALF_FLOAT_OES: return sw::FORMAT_A16B16G16R16F; 467 case GL_FLOAT: return sw::FORMAT_A32B32G32R32F; 468 default: UNREACHABLE(type); 469 } 470 break; 471 case GL_BGRA_EXT: 472 case GL_BGRA8_EXT: 473 switch(type) 474 { 475 case GL_UNSIGNED_BYTE: return sw::FORMAT_A8R8G8B8; 476 case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: return sw::FORMAT_A4R4G4B4; 477 case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: return sw::FORMAT_A1R5G5B5; 478 default: UNREACHABLE(type); 479 } 480 break; 481 case GL_RGB: 482 switch(type) 483 { 484 case GL_UNSIGNED_BYTE: return sw::FORMAT_B8G8R8; 485 case GL_UNSIGNED_SHORT_5_6_5: return sw::FORMAT_R5G6B5; 486 case GL_HALF_FLOAT: return sw::FORMAT_B16G16R16F; 487 case GL_HALF_FLOAT_OES: return sw::FORMAT_B16G16R16F; 488 case GL_FLOAT: return sw::FORMAT_B32G32R32F; 489 default: UNREACHABLE(type); 490 } 491 break; 492 case GL_ALPHA: 493 switch(type) 494 { 495 case GL_UNSIGNED_BYTE: return sw::FORMAT_A8; 496 case GL_HALF_FLOAT: return sw::FORMAT_A16F; 497 case GL_HALF_FLOAT_OES: return sw::FORMAT_A16F; 498 case GL_FLOAT: return sw::FORMAT_A32F; 499 default: UNREACHABLE(type); 500 } 501 break; 502 case GL_ALPHA8_EXT: 503 return sw::FORMAT_A8; 504 case GL_ALPHA16F_EXT: 505 return sw::FORMAT_A16F; 506 case GL_ALPHA32F_EXT: 507 return sw::FORMAT_A32F; 508 case GL_RED_INTEGER: 509 switch(type) 510 { 511 case GL_INT: return sw::FORMAT_R32I; 512 case GL_UNSIGNED_INT: return sw::FORMAT_R32UI; 513 default: UNREACHABLE(type); 514 } 515 break; 516 case GL_RG_INTEGER: 517 switch(type) 518 { 519 case GL_INT: return sw::FORMAT_G32R32I; 520 case GL_UNSIGNED_INT: return sw::FORMAT_G32R32UI; 521 default: UNREACHABLE(type); 522 } 523 break; 524 case GL_RGBA_INTEGER: 525 switch(type) 526 { 527 case GL_INT: return sw::FORMAT_A32B32G32R32I; 528 case GL_UNSIGNED_INT: return sw::FORMAT_A32B32G32R32UI; 529 default: UNREACHABLE(type); 530 } 531 break; 532 case GL_DEPTH_COMPONENT: 533 switch(type) 534 { 535 case GL_UNSIGNED_SHORT: return sw::FORMAT_D16; 536 case GL_UNSIGNED_INT_24_8_OES: return sw::FORMAT_D24S8; 537 case GL_UNSIGNED_INT: return sw::FORMAT_D32; 538 case GL_FLOAT: return sw::FORMAT_D32F; 539 default: UNREACHABLE(type); 540 } 541 break; 542 default: 543 UNREACHABLE(format); 544 } 545 546 return sw::FORMAT_NULL; 547 } 548 549 sw::Format SelectInternalFormat(GLenum format, GLenum type) 550 { 551 switch(format) 552 { 553 case GL_ETC1_RGB8_OES: 554 return sw::FORMAT_ETC1; 555 case GL_COMPRESSED_R11_EAC: 556 return sw::FORMAT_R11_EAC; 557 case GL_COMPRESSED_SIGNED_R11_EAC: 558 return sw::FORMAT_SIGNED_R11_EAC; 559 case GL_COMPRESSED_RG11_EAC: 560 return sw::FORMAT_RG11_EAC; 561 case GL_COMPRESSED_SIGNED_RG11_EAC: 562 return sw::FORMAT_SIGNED_RG11_EAC; 563 case GL_COMPRESSED_RGB8_ETC2: 564 return sw::FORMAT_RGB8_ETC2; 565 case GL_COMPRESSED_SRGB8_ETC2: 566 return sw::FORMAT_SRGB8_ETC2; 567 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 568 return sw::FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; 569 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 570 return sw::FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; 571 case GL_COMPRESSED_RGBA8_ETC2_EAC: 572 return sw::FORMAT_RGBA8_ETC2_EAC; 573 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 574 return sw::FORMAT_SRGB8_ALPHA8_ETC2_EAC; 575 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: 576 return sw::FORMAT_RGBA_ASTC_4x4_KHR; 577 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: 578 return sw::FORMAT_RGBA_ASTC_5x4_KHR; 579 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: 580 return sw::FORMAT_RGBA_ASTC_5x5_KHR; 581 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: 582 return sw::FORMAT_RGBA_ASTC_6x5_KHR; 583 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: 584 return sw::FORMAT_RGBA_ASTC_6x6_KHR; 585 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: 586 return sw::FORMAT_RGBA_ASTC_8x5_KHR; 587 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: 588 return sw::FORMAT_RGBA_ASTC_8x6_KHR; 589 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: 590 return sw::FORMAT_RGBA_ASTC_8x8_KHR; 591 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: 592 return sw::FORMAT_RGBA_ASTC_10x5_KHR; 593 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: 594 return sw::FORMAT_RGBA_ASTC_10x6_KHR; 595 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: 596 return sw::FORMAT_RGBA_ASTC_10x8_KHR; 597 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: 598 return sw::FORMAT_RGBA_ASTC_10x10_KHR; 599 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: 600 return sw::FORMAT_RGBA_ASTC_12x10_KHR; 601 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: 602 return sw::FORMAT_RGBA_ASTC_12x12_KHR; 603 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 604 return sw::FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR; 605 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 606 return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR; 607 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 608 return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR; 609 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 610 return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR; 611 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 612 return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR; 613 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 614 return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR; 615 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 616 return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR; 617 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 618 return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR; 619 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 620 return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR; 621 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 622 return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR; 623 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 624 return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR; 625 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 626 return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR; 627 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 628 return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR; 629 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 630 return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR; 631 #if S3TC_SUPPORT 632 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 633 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 634 return sw::FORMAT_DXT1; 635 case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: 636 return sw::FORMAT_DXT3; 637 case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: 638 return sw::FORMAT_DXT5; 639 #endif 640 default: 641 break; 642 } 643 644 switch(type) 645 { 646 case GL_FLOAT: 647 switch(format) 648 { 649 case GL_ALPHA: 650 case GL_ALPHA32F_EXT: 651 return sw::FORMAT_A32F; 652 case GL_LUMINANCE: 653 case GL_LUMINANCE32F_EXT: 654 return sw::FORMAT_L32F; 655 case GL_LUMINANCE_ALPHA: 656 case GL_LUMINANCE_ALPHA32F_EXT: 657 return sw::FORMAT_A32L32F; 658 case GL_RED: 659 case GL_R32F: 660 return sw::FORMAT_R32F; 661 case GL_RG: 662 case GL_RG32F: 663 return sw::FORMAT_G32R32F; 664 case GL_RGB: 665 case GL_RGB32F: 666 return sw::FORMAT_X32B32G32R32F; 667 case GL_RGBA: 668 case GL_RGBA32F: 669 return sw::FORMAT_A32B32G32R32F; 670 case GL_DEPTH_COMPONENT: 671 case GL_DEPTH_COMPONENT32F: 672 return sw::FORMAT_D32F; 673 default: 674 UNREACHABLE(format); 675 } 676 case GL_HALF_FLOAT: 677 case GL_HALF_FLOAT_OES: 678 switch(format) 679 { 680 case GL_ALPHA: 681 case GL_ALPHA16F_EXT: 682 return sw::FORMAT_A16F; 683 case GL_LUMINANCE: 684 case GL_LUMINANCE16F_EXT: 685 return sw::FORMAT_L16F; 686 case GL_LUMINANCE_ALPHA: 687 case GL_LUMINANCE_ALPHA16F_EXT: 688 return sw::FORMAT_A16L16F; 689 case GL_RED: 690 case GL_R16F: 691 return sw::FORMAT_R16F; 692 case GL_RG: 693 case GL_RG16F: 694 return sw::FORMAT_G16R16F; 695 case GL_RGB: 696 case GL_RGB16F: 697 case GL_RGBA: 698 case GL_RGBA16F: 699 return sw::FORMAT_A16B16G16R16F; 700 default: 701 UNREACHABLE(format); 702 } 703 case GL_BYTE: 704 switch(format) 705 { 706 case GL_R8_SNORM: 707 case GL_R8: 708 case GL_RED: 709 return sw::FORMAT_R8I_SNORM; 710 case GL_R8I: 711 case GL_RED_INTEGER: 712 return sw::FORMAT_R8I; 713 case GL_RG8_SNORM: 714 case GL_RG8: 715 case GL_RG: 716 return sw::FORMAT_G8R8I_SNORM; 717 case GL_RG8I: 718 case GL_RG_INTEGER: 719 return sw::FORMAT_G8R8I; 720 case GL_RGB8_SNORM: 721 case GL_RGB8: 722 case GL_RGB: 723 return sw::FORMAT_X8B8G8R8I_SNORM; 724 case GL_RGB8I: 725 case GL_RGB_INTEGER: 726 return sw::FORMAT_X8B8G8R8I; 727 case GL_RGBA8_SNORM: 728 case GL_RGBA8: 729 case GL_RGBA: 730 return sw::FORMAT_A8B8G8R8I_SNORM; 731 case GL_RGBA8I: 732 case GL_RGBA_INTEGER: 733 return sw::FORMAT_A8B8G8R8I; 734 default: 735 UNREACHABLE(format); 736 } 737 case GL_UNSIGNED_BYTE: 738 switch(format) 739 { 740 case GL_LUMINANCE: 741 case GL_LUMINANCE8_EXT: 742 return sw::FORMAT_L8; 743 case GL_LUMINANCE_ALPHA: 744 case GL_LUMINANCE8_ALPHA8_EXT: 745 return sw::FORMAT_A8L8; 746 case GL_R8_SNORM: 747 case GL_R8: 748 case GL_RED: 749 return sw::FORMAT_R8; 750 case GL_R8UI: 751 case GL_RED_INTEGER: 752 return sw::FORMAT_R8UI; 753 case GL_RG8_SNORM: 754 case GL_RG8: 755 case GL_RG: 756 return sw::FORMAT_G8R8; 757 case GL_RG8UI: 758 case GL_RG_INTEGER: 759 return sw::FORMAT_G8R8UI; 760 case GL_RGB8_SNORM: 761 case GL_RGB8: 762 case GL_RGB: 763 case GL_SRGB8: 764 return sw::FORMAT_X8B8G8R8; 765 case GL_RGB8UI: 766 case GL_RGB_INTEGER: 767 return sw::FORMAT_X8B8G8R8UI; 768 case GL_RGBA8_SNORM: 769 case GL_RGBA8: 770 case GL_RGBA: 771 case GL_SRGB8_ALPHA8: 772 return sw::FORMAT_A8B8G8R8; 773 case GL_RGBA8UI: 774 case GL_RGBA_INTEGER: 775 return sw::FORMAT_A8B8G8R8UI; 776 case GL_BGRA_EXT: 777 case GL_BGRA8_EXT: 778 return sw::FORMAT_A8R8G8B8; 779 case GL_ALPHA: 780 case GL_ALPHA8_EXT: 781 return sw::FORMAT_A8; 782 case SW_YV12_BT601: 783 return sw::FORMAT_YV12_BT601; 784 case SW_YV12_BT709: 785 return sw::FORMAT_YV12_BT709; 786 case SW_YV12_JFIF: 787 return sw::FORMAT_YV12_JFIF; 788 default: 789 UNREACHABLE(format); 790 } 791 case GL_SHORT: 792 switch(format) 793 { 794 case GL_R16I: 795 case GL_RED_INTEGER: 796 return sw::FORMAT_R16I; 797 case GL_RG16I: 798 case GL_RG_INTEGER: 799 return sw::FORMAT_G16R16I; 800 case GL_RGB16I: 801 case GL_RGB_INTEGER: 802 return sw::FORMAT_X16B16G16R16I; 803 case GL_RGBA16I: 804 case GL_RGBA_INTEGER: 805 return sw::FORMAT_A16B16G16R16I; 806 default: 807 UNREACHABLE(format); 808 } 809 case GL_UNSIGNED_SHORT: 810 switch(format) 811 { 812 case GL_R16UI: 813 case GL_RED_INTEGER: 814 return sw::FORMAT_R16UI; 815 case GL_RG16UI: 816 case GL_RG_INTEGER: 817 return sw::FORMAT_G16R16UI; 818 case GL_RGB16UI: 819 case GL_RGB_INTEGER: 820 return sw::FORMAT_X16B16G16R16UI; 821 case GL_RGBA16UI: 822 case GL_RGBA_INTEGER: 823 return sw::FORMAT_A16B16G16R16UI; 824 case GL_DEPTH_COMPONENT: 825 case GL_DEPTH_COMPONENT16: 826 return sw::FORMAT_D32FS8_TEXTURE; 827 default: 828 UNREACHABLE(format); 829 } 830 case GL_INT: 831 switch(format) 832 { 833 case GL_RED_INTEGER: 834 case GL_R32I: 835 return sw::FORMAT_R32I; 836 case GL_RG_INTEGER: 837 case GL_RG32I: 838 return sw::FORMAT_G32R32I; 839 case GL_RGB_INTEGER: 840 case GL_RGB32I: 841 return sw::FORMAT_X32B32G32R32I; 842 case GL_RGBA_INTEGER: 843 case GL_RGBA32I: 844 return sw::FORMAT_A32B32G32R32I; 845 default: 846 UNREACHABLE(format); 847 } 848 case GL_UNSIGNED_INT: 849 switch(format) 850 { 851 case GL_RED_INTEGER: 852 case GL_R32UI: 853 return sw::FORMAT_R32UI; 854 case GL_RG_INTEGER: 855 case GL_RG32UI: 856 return sw::FORMAT_G32R32UI; 857 case GL_RGB_INTEGER: 858 case GL_RGB32UI: 859 return sw::FORMAT_X32B32G32R32UI; 860 case GL_RGBA_INTEGER: 861 case GL_RGBA32UI: 862 return sw::FORMAT_A32B32G32R32UI; 863 case GL_DEPTH_COMPONENT: 864 case GL_DEPTH_COMPONENT16: 865 case GL_DEPTH_COMPONENT24: 866 case GL_DEPTH_COMPONENT32_OES: 867 return sw::FORMAT_D32FS8_TEXTURE; 868 default: 869 UNREACHABLE(format); 870 } 871 case GL_UNSIGNED_INT_24_8_OES: 872 if(format == GL_DEPTH_STENCIL || format == GL_DEPTH24_STENCIL8) 873 { 874 return sw::FORMAT_D32FS8_TEXTURE; 875 } 876 else UNREACHABLE(format); 877 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 878 if(format == GL_DEPTH_STENCIL || format == GL_DEPTH32F_STENCIL8) 879 { 880 return sw::FORMAT_D32FS8_TEXTURE; 881 } 882 else UNREACHABLE(format); 883 case GL_UNSIGNED_SHORT_4_4_4_4: 884 return sw::FORMAT_A8R8G8B8; 885 case GL_UNSIGNED_SHORT_5_5_5_1: 886 return sw::FORMAT_A8R8G8B8; 887 case GL_UNSIGNED_SHORT_5_6_5: 888 return sw::FORMAT_R5G6B5; 889 case GL_UNSIGNED_INT_2_10_10_10_REV: 890 if(format == GL_RGB10_A2UI) 891 { 892 return sw::FORMAT_A16B16G16R16UI; 893 } 894 else 895 { 896 return sw::FORMAT_A2B10G10R10; 897 } 898 case GL_UNSIGNED_INT_10F_11F_11F_REV: 899 case GL_UNSIGNED_INT_5_9_9_9_REV: 900 return sw::FORMAT_A32B32G32R32F; 901 default: 902 UNREACHABLE(type); 903 } 904 905 return sw::FORMAT_NULL; 906 } 907 908 // Returns the size, in bytes, of a single texel in an Image 909 static int ComputePixelSize(GLenum format, GLenum type) 910 { 911 switch(type) 912 { 913 case GL_BYTE: 914 switch(format) 915 { 916 case GL_R8: 917 case GL_R8I: 918 case GL_R8_SNORM: 919 case GL_RED: return sizeof(char); 920 case GL_RED_INTEGER: return sizeof(char); 921 case GL_RG8: 922 case GL_RG8I: 923 case GL_RG8_SNORM: 924 case GL_RG: return sizeof(char) * 2; 925 case GL_RG_INTEGER: return sizeof(char) * 2; 926 case GL_RGB8: 927 case GL_RGB8I: 928 case GL_RGB8_SNORM: 929 case GL_RGB: return sizeof(char) * 3; 930 case GL_RGB_INTEGER: return sizeof(char) * 3; 931 case GL_RGBA8: 932 case GL_RGBA8I: 933 case GL_RGBA8_SNORM: 934 case GL_RGBA: return sizeof(char) * 4; 935 case GL_RGBA_INTEGER: return sizeof(char) * 4; 936 default: UNREACHABLE(format); 937 } 938 break; 939 case GL_UNSIGNED_BYTE: 940 switch(format) 941 { 942 case GL_R8: 943 case GL_R8UI: 944 case GL_RED: return sizeof(unsigned char); 945 case GL_RED_INTEGER: return sizeof(unsigned char); 946 case GL_ALPHA8_EXT: 947 case GL_ALPHA: return sizeof(unsigned char); 948 case GL_LUMINANCE8_EXT: 949 case GL_LUMINANCE: return sizeof(unsigned char); 950 case GL_LUMINANCE8_ALPHA8_EXT: 951 case GL_LUMINANCE_ALPHA: return sizeof(unsigned char) * 2; 952 case GL_RG8: 953 case GL_RG8UI: 954 case GL_RG: return sizeof(unsigned char) * 2; 955 case GL_RG_INTEGER: return sizeof(unsigned char) * 2; 956 case GL_RGB8: 957 case GL_RGB8UI: 958 case GL_SRGB8: 959 case GL_RGB: return sizeof(unsigned char) * 3; 960 case GL_RGB_INTEGER: return sizeof(unsigned char) * 3; 961 case GL_RGBA8: 962 case GL_RGBA8UI: 963 case GL_SRGB8_ALPHA8: 964 case GL_RGBA: return sizeof(unsigned char) * 4; 965 case GL_RGBA_INTEGER: return sizeof(unsigned char) * 4; 966 case GL_BGRA_EXT: 967 case GL_BGRA8_EXT: return sizeof(unsigned char)* 4; 968 default: UNREACHABLE(format); 969 } 970 break; 971 case GL_SHORT: 972 switch(format) 973 { 974 case GL_R16I: 975 case GL_RED_INTEGER: return sizeof(short); 976 case GL_RG16I: 977 case GL_RG_INTEGER: return sizeof(short) * 2; 978 case GL_RGB16I: 979 case GL_RGB_INTEGER: return sizeof(short) * 3; 980 case GL_RGBA16I: 981 case GL_RGBA_INTEGER: return sizeof(short) * 4; 982 default: UNREACHABLE(format); 983 } 984 break; 985 case GL_UNSIGNED_SHORT: 986 switch(format) 987 { 988 case GL_DEPTH_COMPONENT16: 989 case GL_DEPTH_COMPONENT: return sizeof(unsigned short); 990 case GL_R16UI: 991 case GL_RED_INTEGER: return sizeof(unsigned short); 992 case GL_RG16UI: 993 case GL_RG_INTEGER: return sizeof(unsigned short) * 2; 994 case GL_RGB16UI: 995 case GL_RGB_INTEGER: return sizeof(unsigned short) * 3; 996 case GL_RGBA16UI: 997 case GL_RGBA_INTEGER: return sizeof(unsigned short) * 4; 998 default: UNREACHABLE(format); 999 } 1000 break; 1001 case GL_INT: 1002 switch(format) 1003 { 1004 case GL_R32I: 1005 case GL_RED_INTEGER: return sizeof(int); 1006 case GL_RG32I: 1007 case GL_RG_INTEGER: return sizeof(int) * 2; 1008 case GL_RGB32I: 1009 case GL_RGB_INTEGER: return sizeof(int) * 3; 1010 case GL_RGBA32I: 1011 case GL_RGBA_INTEGER: return sizeof(int) * 4; 1012 default: UNREACHABLE(format); 1013 } 1014 break; 1015 case GL_UNSIGNED_INT: 1016 switch(format) 1017 { 1018 case GL_DEPTH_COMPONENT16: 1019 case GL_DEPTH_COMPONENT24: 1020 case GL_DEPTH_COMPONENT32_OES: 1021 case GL_DEPTH_COMPONENT: return sizeof(unsigned int); 1022 case GL_R32UI: 1023 case GL_RED_INTEGER: return sizeof(unsigned int); 1024 case GL_RG32UI: 1025 case GL_RG_INTEGER: return sizeof(unsigned int) * 2; 1026 case GL_RGB32UI: 1027 case GL_RGB_INTEGER: return sizeof(unsigned int) * 3; 1028 case GL_RGBA32UI: 1029 case GL_RGBA_INTEGER: return sizeof(unsigned int) * 4; 1030 default: UNREACHABLE(format); 1031 } 1032 break; 1033 case GL_UNSIGNED_SHORT_4_4_4_4: 1034 case GL_UNSIGNED_SHORT_5_5_5_1: 1035 case GL_UNSIGNED_SHORT_5_6_5: 1036 case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: 1037 case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: 1038 return sizeof(unsigned short); 1039 case GL_UNSIGNED_INT_10F_11F_11F_REV: 1040 case GL_UNSIGNED_INT_5_9_9_9_REV: 1041 case GL_UNSIGNED_INT_2_10_10_10_REV: 1042 case GL_UNSIGNED_INT_24_8_OES: 1043 return sizeof(unsigned int); 1044 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 1045 return sizeof(float) + sizeof(unsigned int); 1046 case GL_FLOAT: 1047 switch(format) 1048 { 1049 case GL_DEPTH_COMPONENT32F: 1050 case GL_DEPTH_COMPONENT: return sizeof(float); 1051 case GL_ALPHA32F_EXT: 1052 case GL_ALPHA: return sizeof(float); 1053 case GL_LUMINANCE32F_EXT: 1054 case GL_LUMINANCE: return sizeof(float); 1055 case GL_LUMINANCE_ALPHA32F_EXT: 1056 case GL_LUMINANCE_ALPHA: return sizeof(float) * 2; 1057 case GL_RED: return sizeof(float); 1058 case GL_R32F: return sizeof(float); 1059 case GL_RG: return sizeof(float) * 2; 1060 case GL_RG32F: return sizeof(float) * 2; 1061 case GL_RGB: return sizeof(float) * 3; 1062 case GL_RGB32F: return sizeof(float) * 3; 1063 case GL_RGBA: return sizeof(float) * 4; 1064 case GL_RGBA32F: return sizeof(float) * 4; 1065 default: UNREACHABLE(format); 1066 } 1067 break; 1068 case GL_HALF_FLOAT: 1069 case GL_HALF_FLOAT_OES: 1070 switch(format) 1071 { 1072 case GL_ALPHA16F_EXT: 1073 case GL_ALPHA: return sizeof(unsigned short); 1074 case GL_LUMINANCE16F_EXT: 1075 case GL_LUMINANCE: return sizeof(unsigned short); 1076 case GL_LUMINANCE_ALPHA16F_EXT: 1077 case GL_LUMINANCE_ALPHA: return sizeof(unsigned short) * 2; 1078 case GL_RED: return sizeof(unsigned short); 1079 case GL_R16F: return sizeof(unsigned short); 1080 case GL_RG: return sizeof(unsigned short) * 2; 1081 case GL_RG16F: return sizeof(unsigned short) * 2; 1082 case GL_RGB: return sizeof(unsigned short) * 3; 1083 case GL_RGB16F: return sizeof(unsigned short) * 3; 1084 case GL_RGBA: return sizeof(unsigned short) * 4; 1085 case GL_RGBA16F: return sizeof(unsigned short) * 4; 1086 default: UNREACHABLE(format); 1087 } 1088 break; 1089 default: UNREACHABLE(type); 1090 } 1091 1092 return 0; 1093 } 1094 1095 GLsizei ComputePitch(GLsizei width, GLenum format, GLenum type, GLint alignment) 1096 { 1097 ASSERT(alignment > 0 && sw::isPow2(alignment)); 1098 1099 GLsizei rawPitch = ComputePixelSize(format, type) * width; 1100 return (rawPitch + alignment - 1) & ~(alignment - 1); 1101 } 1102 1103 size_t ComputePackingOffset(GLenum format, GLenum type, GLsizei width, GLsizei height, GLint alignment, GLint skipImages, GLint skipRows, GLint skipPixels) 1104 { 1105 GLsizei pitchB = ComputePitch(width, format, type, alignment); 1106 return (skipImages * height + skipRows) * pitchB + skipPixels * ComputePixelSize(format, type); 1107 } 1108 1109 inline GLsizei ComputeCompressedPitch(GLsizei width, GLenum format) 1110 { 1111 return ComputeCompressedSize(width, 1, format); 1112 } 1113 1114 GLsizei ComputeCompressedSize(GLsizei width, GLsizei height, GLenum format) 1115 { 1116 switch(format) 1117 { 1118 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 1119 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 1120 case GL_ETC1_RGB8_OES: 1121 case GL_COMPRESSED_R11_EAC: 1122 case GL_COMPRESSED_SIGNED_R11_EAC: 1123 case GL_COMPRESSED_RGB8_ETC2: 1124 case GL_COMPRESSED_SRGB8_ETC2: 1125 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 1126 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 1127 return 8 * getNumBlocks(width, height, 4, 4); 1128 case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: 1129 case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: 1130 case GL_COMPRESSED_RG11_EAC: 1131 case GL_COMPRESSED_SIGNED_RG11_EAC: 1132 case GL_COMPRESSED_RGBA8_ETC2_EAC: 1133 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 1134 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: 1135 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 1136 return 16 * getNumBlocks(width, height, 4, 4); 1137 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: 1138 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 1139 return 16 * getNumBlocks(width, height, 5, 4); 1140 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: 1141 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 1142 return 16 * getNumBlocks(width, height, 5, 5); 1143 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: 1144 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 1145 return 16 * getNumBlocks(width, height, 6, 5); 1146 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: 1147 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 1148 return 16 * getNumBlocks(width, height, 6, 6); 1149 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: 1150 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 1151 return 16 * getNumBlocks(width, height, 8, 5); 1152 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: 1153 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 1154 return 16 * getNumBlocks(width, height, 8, 6); 1155 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: 1156 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 1157 return 16 * getNumBlocks(width, height, 8, 8); 1158 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: 1159 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 1160 return 16 * getNumBlocks(width, height, 10, 5); 1161 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: 1162 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 1163 return 16 * getNumBlocks(width, height, 10, 6); 1164 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: 1165 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 1166 return 16 * getNumBlocks(width, height, 10, 8); 1167 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: 1168 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 1169 return 16 * getNumBlocks(width, height, 10, 10); 1170 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: 1171 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 1172 return 16 * getNumBlocks(width, height, 12, 10); 1173 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: 1174 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 1175 return 16 * getNumBlocks(width, height, 12, 12); 1176 default: 1177 return 0; 1178 } 1179 } 1180 1181 class ImageImplementation : public Image 1182 { 1183 public: 1184 ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type) 1185 : Image(parentTexture, width, height, format, type) {} 1186 ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type) 1187 : Image(parentTexture, width, height, depth, format, type) {} 1188 ImageImplementation(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP) 1189 : Image(width, height, format, type, pitchP) {} 1190 ImageImplementation(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable) 1191 : Image(width, height, internalFormat, multiSampleDepth, lockable) {} 1192 1193 ~ImageImplementation() override 1194 { 1195 sync(); // Wait for any threads that use this image to finish. 1196 } 1197 1198 void *lockInternal(int x, int y, int z, sw::Lock lock, sw::Accessor client) override 1199 { 1200 return Image::lockInternal(x, y, z, lock, client); 1201 } 1202 1203 void unlockInternal() override 1204 { 1205 return Image::unlockInternal(); 1206 } 1207 1208 void release() override 1209 { 1210 return Image::release(); 1211 } 1212 }; 1213 1214 Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type) 1215 { 1216 return new ImageImplementation(parentTexture, width, height, format, type); 1217 } 1218 1219 Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type) 1220 { 1221 return new ImageImplementation(parentTexture, width, height, depth, format, type); 1222 } 1223 1224 Image *Image::create(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP) 1225 { 1226 return new ImageImplementation(width, height, format, type, pitchP); 1227 } 1228 1229 Image *Image::create(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable) 1230 { 1231 return new ImageImplementation(width, height, internalFormat, multiSampleDepth, lockable); 1232 } 1233 1234 Image::~Image() 1235 { 1236 // sync() must be called in the destructor of the most derived class to ensure their vtable isn't destroyed 1237 // before all threads are done using this image. Image itself is abstract so it can't be the most derived. 1238 ASSERT(isUnlocked()); 1239 1240 if(parentTexture) 1241 { 1242 parentTexture->release(); 1243 } 1244 1245 ASSERT(!shared); 1246 } 1247 1248 void *Image::lockInternal(int x, int y, int z, sw::Lock lock, sw::Accessor client) 1249 { 1250 return Surface::lockInternal(x, y, z, lock, client); 1251 } 1252 1253 void Image::unlockInternal() 1254 { 1255 Surface::unlockInternal(); 1256 } 1257 1258 void Image::release() 1259 { 1260 int refs = dereference(); 1261 1262 if(refs > 0) 1263 { 1264 if(parentTexture) 1265 { 1266 parentTexture->sweep(); 1267 } 1268 } 1269 else 1270 { 1271 delete this; 1272 } 1273 } 1274 1275 void Image::unbind(const egl::Texture *parent) 1276 { 1277 if(parentTexture == parent) 1278 { 1279 parentTexture = nullptr; 1280 } 1281 1282 release(); 1283 } 1284 1285 bool Image::isChildOf(const egl::Texture *parent) const 1286 { 1287 return parentTexture == parent; 1288 } 1289 1290 void Image::loadImageData(Context *context, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const UnpackInfo& unpackInfo, const void *input) 1291 { 1292 sw::Format selectedInternalFormat = SelectInternalFormat(format, type); 1293 if(selectedInternalFormat == sw::FORMAT_NULL) 1294 { 1295 return; 1296 } 1297 1298 GLsizei inputWidth = (unpackInfo.rowLength == 0) ? width : unpackInfo.rowLength; 1299 GLsizei inputPitch = ComputePitch(inputWidth, format, type, unpackInfo.alignment); 1300 GLsizei inputHeight = (unpackInfo.imageHeight == 0) ? height : unpackInfo.imageHeight; 1301 input = ((char*)input) + ComputePackingOffset(format, type, inputWidth, inputHeight, unpackInfo.alignment, unpackInfo.skipImages, unpackInfo.skipRows, unpackInfo.skipPixels); 1302 1303 if(selectedInternalFormat == internalFormat) 1304 { 1305 void *buffer = lock(0, 0, sw::LOCK_WRITEONLY); 1306 1307 if(buffer) 1308 { 1309 switch(type) 1310 { 1311 case GL_BYTE: 1312 switch(format) 1313 { 1314 case GL_R8: 1315 case GL_R8I: 1316 case GL_R8_SNORM: 1317 case GL_RED: 1318 case GL_RED_INTEGER: 1319 case GL_ALPHA: 1320 case GL_ALPHA8_EXT: 1321 case GL_LUMINANCE: 1322 case GL_LUMINANCE8_EXT: 1323 LoadImageData<Bytes_1>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1324 break; 1325 case GL_RG8: 1326 case GL_RG8I: 1327 case GL_RG8_SNORM: 1328 case GL_RG: 1329 case GL_RG_INTEGER: 1330 case GL_LUMINANCE_ALPHA: 1331 case GL_LUMINANCE8_ALPHA8_EXT: 1332 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1333 break; 1334 case GL_RGB8: 1335 case GL_RGB8I: 1336 case GL_RGB8_SNORM: 1337 case GL_RGB: 1338 case GL_RGB_INTEGER: 1339 LoadImageData<ByteRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1340 break; 1341 case GL_RGBA8: 1342 case GL_RGBA8I: 1343 case GL_RGBA8_SNORM: 1344 case GL_RGBA: 1345 case GL_RGBA_INTEGER: 1346 case GL_BGRA_EXT: 1347 case GL_BGRA8_EXT: 1348 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1349 break; 1350 default: UNREACHABLE(format); 1351 } 1352 break; 1353 case GL_UNSIGNED_BYTE: 1354 switch(format) 1355 { 1356 case GL_R8: 1357 case GL_R8UI: 1358 case GL_R8_SNORM: 1359 case GL_RED: 1360 case GL_RED_INTEGER: 1361 case GL_ALPHA: 1362 case GL_ALPHA8_EXT: 1363 case GL_LUMINANCE: 1364 case GL_LUMINANCE8_EXT: 1365 LoadImageData<Bytes_1>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1366 break; 1367 case GL_RG8: 1368 case GL_RG8UI: 1369 case GL_RG8_SNORM: 1370 case GL_RG: 1371 case GL_RG_INTEGER: 1372 case GL_LUMINANCE_ALPHA: 1373 case GL_LUMINANCE8_ALPHA8_EXT: 1374 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1375 break; 1376 case GL_RGB8: 1377 case GL_RGB8UI: 1378 case GL_RGB8_SNORM: 1379 case GL_RGB: 1380 case GL_RGB_INTEGER: 1381 LoadImageData<UByteRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1382 break; 1383 case GL_RGBA8: 1384 case GL_RGBA8UI: 1385 case GL_RGBA8_SNORM: 1386 case GL_RGBA: 1387 case GL_RGBA_INTEGER: 1388 case GL_BGRA_EXT: 1389 case GL_BGRA8_EXT: 1390 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1391 break; 1392 case GL_SRGB8: 1393 LoadImageData<SRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1394 break; 1395 case GL_SRGB8_ALPHA8: 1396 LoadImageData<SRGBA>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1397 break; 1398 default: UNREACHABLE(format); 1399 } 1400 break; 1401 case GL_UNSIGNED_SHORT_5_6_5: 1402 switch(format) 1403 { 1404 case GL_RGB565: 1405 case GL_RGB: 1406 LoadImageData<RGB565>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1407 break; 1408 default: UNREACHABLE(format); 1409 } 1410 break; 1411 case GL_UNSIGNED_SHORT_4_4_4_4: 1412 switch(format) 1413 { 1414 case GL_RGBA4: 1415 case GL_RGBA: 1416 LoadImageData<RGBA4444>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1417 break; 1418 default: UNREACHABLE(format); 1419 } 1420 break; 1421 case GL_UNSIGNED_SHORT_5_5_5_1: 1422 switch(format) 1423 { 1424 case GL_RGB5_A1: 1425 case GL_RGBA: 1426 LoadImageData<RGBA5551>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1427 break; 1428 default: UNREACHABLE(format); 1429 } 1430 break; 1431 case GL_UNSIGNED_INT_10F_11F_11F_REV: 1432 switch(format) 1433 { 1434 case GL_R11F_G11F_B10F: 1435 case GL_RGB: 1436 LoadImageData<R11G11B10F>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1437 break; 1438 default: UNREACHABLE(format); 1439 } 1440 break; 1441 case GL_UNSIGNED_INT_5_9_9_9_REV: 1442 switch(format) 1443 { 1444 case GL_RGB9_E5: 1445 case GL_RGB: 1446 LoadImageData<RGB9E5>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1447 break; 1448 default: UNREACHABLE(format); 1449 } 1450 break; 1451 case GL_UNSIGNED_INT_2_10_10_10_REV: 1452 switch(format) 1453 { 1454 case GL_RGB10_A2UI: 1455 LoadImageData<RGB10A2UI>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1456 break; 1457 case GL_RGB10_A2: 1458 case GL_RGBA: 1459 case GL_RGBA_INTEGER: 1460 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1461 break; 1462 default: UNREACHABLE(format); 1463 } 1464 break; 1465 case GL_FLOAT: 1466 switch(format) 1467 { 1468 // float textures are converted to RGBA, not BGRA 1469 case GL_ALPHA: 1470 case GL_ALPHA32F_EXT: 1471 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1472 break; 1473 case GL_LUMINANCE: 1474 case GL_LUMINANCE32F_EXT: 1475 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1476 break; 1477 case GL_LUMINANCE_ALPHA: 1478 case GL_LUMINANCE_ALPHA32F_EXT: 1479 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1480 break; 1481 case GL_RED: 1482 case GL_R32F: 1483 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1484 break; 1485 case GL_RG: 1486 case GL_RG32F: 1487 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1488 break; 1489 case GL_RGB: 1490 case GL_RGB32F: 1491 LoadImageData<FloatRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1492 break; 1493 case GL_RGBA: 1494 case GL_RGBA32F: 1495 LoadImageData<Bytes_16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1496 break; 1497 case GL_DEPTH_COMPONENT: 1498 case GL_DEPTH_COMPONENT32F: 1499 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1500 break; 1501 default: UNREACHABLE(format); 1502 } 1503 break; 1504 case GL_HALF_FLOAT: 1505 case GL_HALF_FLOAT_OES: 1506 switch(format) 1507 { 1508 case GL_ALPHA: 1509 case GL_ALPHA16F_EXT: 1510 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1511 break; 1512 case GL_LUMINANCE: 1513 case GL_LUMINANCE16F_EXT: 1514 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1515 break; 1516 case GL_LUMINANCE_ALPHA: 1517 case GL_LUMINANCE_ALPHA16F_EXT: 1518 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1519 break; 1520 case GL_RED: 1521 case GL_R16F: 1522 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1523 break; 1524 case GL_RG: 1525 case GL_RG16F: 1526 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1527 break; 1528 case GL_RGB: 1529 case GL_RGB16F: 1530 LoadImageData<HalfFloatRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1531 break; 1532 case GL_RGBA: 1533 case GL_RGBA16F: 1534 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1535 break; 1536 default: UNREACHABLE(format); 1537 } 1538 break; 1539 case GL_SHORT: 1540 switch(format) 1541 { 1542 case GL_R16I: 1543 case GL_RED: 1544 case GL_RED_INTEGER: 1545 case GL_ALPHA: 1546 case GL_LUMINANCE: 1547 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1548 break; 1549 case GL_RG16I: 1550 case GL_RG: 1551 case GL_RG_INTEGER: 1552 case GL_LUMINANCE_ALPHA: 1553 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1554 break; 1555 case GL_RGB16I: 1556 case GL_RGB: 1557 case GL_RGB_INTEGER: 1558 LoadImageData<ShortRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1559 break; 1560 case GL_RGBA16I: 1561 case GL_RGBA: 1562 case GL_RGBA_INTEGER: 1563 case GL_BGRA_EXT: 1564 case GL_BGRA8_EXT: 1565 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1566 break; 1567 default: UNREACHABLE(format); 1568 } 1569 break; 1570 case GL_UNSIGNED_SHORT: 1571 switch(format) 1572 { 1573 case GL_R16UI: 1574 case GL_RED: 1575 case GL_RED_INTEGER: 1576 case GL_ALPHA: 1577 case GL_LUMINANCE: 1578 LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1579 break; 1580 case GL_RG16UI: 1581 case GL_RG: 1582 case GL_RG_INTEGER: 1583 case GL_LUMINANCE_ALPHA: 1584 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1585 break; 1586 case GL_RGB16UI: 1587 case GL_RGB: 1588 case GL_RGB_INTEGER: 1589 LoadImageData<UShortRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1590 break; 1591 case GL_RGBA16UI: 1592 case GL_RGBA: 1593 case GL_RGBA_INTEGER: 1594 case GL_BGRA_EXT: 1595 case GL_BGRA8_EXT: 1596 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1597 break; 1598 case GL_DEPTH_COMPONENT: 1599 case GL_DEPTH_COMPONENT16: 1600 LoadImageData<D16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1601 break; 1602 default: UNREACHABLE(format); 1603 } 1604 break; 1605 case GL_INT: 1606 switch(format) 1607 { 1608 case GL_R32I: 1609 case GL_RED: 1610 case GL_RED_INTEGER: 1611 case GL_ALPHA: 1612 case GL_LUMINANCE: 1613 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1614 break; 1615 case GL_RG32I: 1616 case GL_RG: 1617 case GL_RG_INTEGER: 1618 case GL_LUMINANCE_ALPHA: 1619 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1620 break; 1621 case GL_RGB32I: 1622 case GL_RGB: 1623 case GL_RGB_INTEGER: 1624 LoadImageData<IntRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1625 break; 1626 case GL_RGBA32I: 1627 case GL_RGBA: 1628 case GL_RGBA_INTEGER: 1629 case GL_BGRA_EXT: 1630 case GL_BGRA8_EXT: 1631 LoadImageData<Bytes_16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1632 break; 1633 default: UNREACHABLE(format); 1634 } 1635 break; 1636 case GL_UNSIGNED_INT: 1637 switch(format) 1638 { 1639 case GL_R32UI: 1640 case GL_RED: 1641 case GL_RED_INTEGER: 1642 case GL_ALPHA: 1643 case GL_LUMINANCE: 1644 LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1645 break; 1646 case GL_RG32UI: 1647 case GL_RG: 1648 case GL_RG_INTEGER: 1649 case GL_LUMINANCE_ALPHA: 1650 LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1651 break; 1652 case GL_RGB32UI: 1653 case GL_RGB: 1654 case GL_RGB_INTEGER: 1655 LoadImageData<UIntRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1656 break; 1657 case GL_RGBA32UI: 1658 case GL_RGBA: 1659 case GL_RGBA_INTEGER: 1660 case GL_BGRA_EXT: 1661 case GL_BGRA8_EXT: 1662 LoadImageData<Bytes_16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1663 break; 1664 case GL_DEPTH_COMPONENT16: 1665 case GL_DEPTH_COMPONENT24: 1666 case GL_DEPTH_COMPONENT32_OES: 1667 case GL_DEPTH_COMPONENT: 1668 LoadImageData<D32>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1669 break; 1670 default: UNREACHABLE(format); 1671 } 1672 break; 1673 case GL_UNSIGNED_INT_24_8_OES: 1674 loadD24S8ImageData(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, input, buffer); 1675 break; 1676 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 1677 loadD32FS8ImageData(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, input, buffer); 1678 break; 1679 default: UNREACHABLE(type); 1680 } 1681 } 1682 1683 unlock(); 1684 } 1685 else 1686 { 1687 sw::Surface *source = sw::Surface::create(width, height, depth, ConvertFormatType(format, type), const_cast<void*>(input), inputPitch, inputPitch * inputHeight); 1688 sw::Rect sourceRect(0, 0, width, height); 1689 sw::Rect destRect(xoffset, yoffset, xoffset + width, yoffset + height); 1690 context->blit(source, sourceRect, this, destRect); 1691 delete source; 1692 } 1693 } 1694 1695 void Image::loadD24S8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer) 1696 { 1697 LoadImageData<D24>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1698 1699 unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(0, 0, 0, sw::PUBLIC)); 1700 1701 if(stencil) 1702 { 1703 LoadImageData<S8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getStencilPitchB(), getHeight(), input, stencil); 1704 1705 unlockStencil(); 1706 } 1707 } 1708 1709 void Image::loadD32FS8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer) 1710 { 1711 LoadImageData<D32F>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer); 1712 1713 unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(0, 0, 0, sw::PUBLIC)); 1714 1715 if(stencil) 1716 { 1717 LoadImageData<S24_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getStencilPitchB(), getHeight(), input, stencil); 1718 1719 unlockStencil(); 1720 } 1721 } 1722 1723 void Image::loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) 1724 { 1725 if(zoffset != 0 || depth != 1) 1726 { 1727 UNIMPLEMENTED(); // FIXME 1728 } 1729 1730 int inputPitch = ComputeCompressedPitch(width, format); 1731 int rows = imageSize / inputPitch; 1732 void *buffer = lock(xoffset, yoffset, sw::LOCK_WRITEONLY); 1733 1734 if(buffer) 1735 { 1736 for(int i = 0; i < rows; i++) 1737 { 1738 memcpy((void*)((GLbyte*)buffer + i * getPitch()), (void*)((GLbyte*)pixels + i * inputPitch), inputPitch); 1739 } 1740 } 1741 1742 unlock(); 1743 } 1744 } 1745
