projects / mesa.git / blob
? search:


3314e557c0ad2f12cc6b8688ed3ba7ac0142d8a1
[mesa.git] / src / mesa / main / texstore.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (c) 2008-2009 VMware, Inc.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 /*
27 * Authors:
28 * Brian Paul
29 */
30
31 /**
32 * The GL texture image functions in teximage.c basically just do
33 * error checking and data structure allocation. They in turn call
34 * device driver functions which actually copy/convert/store the user's
35 * texture image data.
36 *
37 * However, most device drivers will be able to use the fallback functions
38 * in this file. That is, most drivers will have the following bit of
39 * code:
40 * ctx->Driver.TexImage = _mesa_store_teximage;
41 * ctx->Driver.TexSubImage = _mesa_store_texsubimage;
42 * etc...
43 *
44 * Texture image processing is actually kind of complicated. We have to do:
45 * Format/type conversions
46 * pixel unpacking
47 * pixel transfer (scale, bais, lookup, etc)
48 *
49 * These functions can handle most everything, including processing full
50 * images and sub-images.
51 */
52
53
54 #include "glheader.h"
55 #include "bufferobj.h"
56 #include "format_pack.h"
57 #include "format_utils.h"
58 #include "image.h"
59 #include "macros.h"
60 #include "mipmap.h"
61 #include "mtypes.h"
62 #include "pack.h"
63 #include "pbo.h"
64 #include "imports.h"
65 #include "texcompress.h"
66 #include "texcompress_fxt1.h"
67 #include "texcompress_rgtc.h"
68 #include "texcompress_s3tc.h"
69 #include "texcompress_etc.h"
70 #include "texcompress_bptc.h"
71 #include "teximage.h"
72 #include "texstore.h"
73 #include "enums.h"
74 #include "glformats.h"
75 #include "pixeltransfer.h"
76 #include "util/format_rgb9e5.h"
77 #include "util/format_r11g11b10f.h"
78
79
80 enum {
81 ZERO = 4,
82 ONE = 5
83 };
84
85
86 /**
87 * Texture image storage function.
88 */
89 typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
90
91
92 /**
93 * Teximage storage routine for when a simple memcpy will do.
94 * No pixel transfer operations or special texel encodings allowed.
95 * 1D, 2D and 3D images supported.
96 */
97 void
98 _mesa_memcpy_texture(struct gl_context *ctx,
99 GLuint dimensions,
100 mesa_format dstFormat,
101 GLint dstRowStride,
102 GLubyte **dstSlices,
103 GLint srcWidth, GLint srcHeight, GLint srcDepth,
104 GLenum srcFormat, GLenum srcType,
105 const GLvoid *srcAddr,
106 const struct gl_pixelstore_attrib *srcPacking)
107 {
108 const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
109 srcFormat, srcType);
110 const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
111 srcWidth, srcHeight, srcFormat, srcType);
112 const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,
113 srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
114 const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
115 const GLint bytesPerRow = srcWidth * texelBytes;
116
117 if (dstRowStride == srcRowStride &&
118 dstRowStride == bytesPerRow) {
119 /* memcpy image by image */
120 GLint img;
121 for (img = 0; img < srcDepth; img++) {
122 GLubyte *dstImage = dstSlices[img];
123 memcpy(dstImage, srcImage, bytesPerRow * srcHeight);
124 srcImage += srcImageStride;
125 }
126 }
127 else {
128 /* memcpy row by row */
129 GLint img, row;
130 for (img = 0; img < srcDepth; img++) {
131 const GLubyte *srcRow = srcImage;
132 GLubyte *dstRow = dstSlices[img];
133 for (row = 0; row < srcHeight; row++) {
134 memcpy(dstRow, srcRow, bytesPerRow);
135 dstRow += dstRowStride;
136 srcRow += srcRowStride;
137 }
138 srcImage += srcImageStride;
139 }
140 }
141 }
142
143
144 /**
145 * Store a 32-bit integer or float depth component texture image.
146 */
147 static GLboolean
148 _mesa_texstore_z32(TEXSTORE_PARAMS)
149 {
150 const GLuint depthScale = 0xffffffff;
151 GLenum dstType;
152 (void) dims;
153 assert(dstFormat == MESA_FORMAT_Z_UNORM32 ||
154 dstFormat == MESA_FORMAT_Z_FLOAT32);
155 assert(_mesa_get_format_bytes(dstFormat) == sizeof(GLuint));
156
157 if (dstFormat == MESA_FORMAT_Z_UNORM32)
158 dstType = GL_UNSIGNED_INT;
159 else
160 dstType = GL_FLOAT;
161
162 {
163 /* general path */
164 GLint img, row;
165 for (img = 0; img < srcDepth; img++) {
166 GLubyte *dstRow = dstSlices[img];
167 for (row = 0; row < srcHeight; row++) {
168 const GLvoid *src = _mesa_image_address(dims, srcPacking,
169 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
170 _mesa_unpack_depth_span(ctx, srcWidth,
171 dstType, dstRow,
172 depthScale, srcType, src, srcPacking);
173 dstRow += dstRowStride;
174 }
175 }
176 }
177 return GL_TRUE;
178 }
179
180
181 /**
182 * Store a 24-bit integer depth component texture image.
183 */
184 static GLboolean
185 _mesa_texstore_x8_z24(TEXSTORE_PARAMS)
186 {
187 const GLuint depthScale = 0xffffff;
188
189 (void) dims;
190 assert(dstFormat == MESA_FORMAT_Z24_UNORM_X8_UINT);
191
192 {
193 /* general path */
194 GLint img, row;
195 for (img = 0; img < srcDepth; img++) {
196 GLubyte *dstRow = dstSlices[img];
197 for (row = 0; row < srcHeight; row++) {
198 const GLvoid *src = _mesa_image_address(dims, srcPacking,
199 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
200 _mesa_unpack_depth_span(ctx, srcWidth,
201 GL_UNSIGNED_INT, (GLuint *) dstRow,
202 depthScale, srcType, src, srcPacking);
203 dstRow += dstRowStride;
204 }
205 }
206 }
207 return GL_TRUE;
208 }
209
210
211 /**
212 * Store a 24-bit integer depth component texture image.
213 */
214 static GLboolean
215 _mesa_texstore_z24_x8(TEXSTORE_PARAMS)
216 {
217 const GLuint depthScale = 0xffffff;
218
219 (void) dims;
220 assert(dstFormat == MESA_FORMAT_X8_UINT_Z24_UNORM);
221
222 {
223 /* general path */
224 GLint img, row;
225 for (img = 0; img < srcDepth; img++) {
226 GLubyte *dstRow = dstSlices[img];
227 for (row = 0; row < srcHeight; row++) {
228 const GLvoid *src = _mesa_image_address(dims, srcPacking,
229 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
230 GLuint *dst = (GLuint *) dstRow;
231 GLint i;
232 _mesa_unpack_depth_span(ctx, srcWidth,
233 GL_UNSIGNED_INT, dst,
234 depthScale, srcType, src, srcPacking);
235 for (i = 0; i < srcWidth; i++)
236 dst[i] <<= 8;
237 dstRow += dstRowStride;
238 }
239 }
240 }
241 return GL_TRUE;
242 }
243
244
245 /**
246 * Store a 16-bit integer depth component texture image.
247 */
248 static GLboolean
249 _mesa_texstore_z16(TEXSTORE_PARAMS)
250 {
251 const GLuint depthScale = 0xffff;
252 (void) dims;
253 assert(dstFormat == MESA_FORMAT_Z_UNORM16);
254 assert(_mesa_get_format_bytes(dstFormat) == sizeof(GLushort));
255
256 {
257 /* general path */
258 GLint img, row;
259 for (img = 0; img < srcDepth; img++) {
260 GLubyte *dstRow = dstSlices[img];
261 for (row = 0; row < srcHeight; row++) {
262 const GLvoid *src = _mesa_image_address(dims, srcPacking,
263 srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
264 GLushort *dst16 = (GLushort *) dstRow;
265 _mesa_unpack_depth_span(ctx, srcWidth,
266 GL_UNSIGNED_SHORT, dst16, depthScale,
267 srcType, src, srcPacking);
268 dstRow += dstRowStride;
269 }
270 }
271 }
272 return GL_TRUE;
273 }
274
275
276 /**
277 * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
278 */
279 static GLboolean
280 _mesa_texstore_ycbcr(TEXSTORE_PARAMS)
281 {
282 const GLboolean littleEndian = _mesa_little_endian();
283
284 (void) ctx; (void) dims; (void) baseInternalFormat;
285
286 assert((dstFormat == MESA_FORMAT_YCBCR) ||
287 (dstFormat == MESA_FORMAT_YCBCR_REV));
288 assert(_mesa_get_format_bytes(dstFormat) == 2);
289 assert(ctx->Extensions.MESA_ycbcr_texture);
290 assert(srcFormat == GL_YCBCR_MESA);
291 assert((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||
292 (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
293 assert(baseInternalFormat == GL_YCBCR_MESA);
294
295 /* always just memcpy since no pixel transfer ops apply */
296 _mesa_memcpy_texture(ctx, dims,
297 dstFormat,
298 dstRowStride, dstSlices,
299 srcWidth, srcHeight, srcDepth, srcFormat, srcType,
300 srcAddr, srcPacking);
301
302 /* Check if we need byte swapping */
303 /* XXX the logic here _might_ be wrong */
304 if (srcPacking->SwapBytes ^
305 (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
306 (dstFormat == MESA_FORMAT_YCBCR_REV) ^
307 !littleEndian) {
308 GLint img, row;
309 for (img = 0; img < srcDepth; img++) {
310 GLubyte *dstRow = dstSlices[img];
311 for (row = 0; row < srcHeight; row++) {
312 _mesa_swap2((GLushort *) dstRow, srcWidth);
313 dstRow += dstRowStride;
314 }
315 }
316 }
317 return GL_TRUE;
318 }
319
320
321 /**
322 * Store a combined depth/stencil texture image.
323 */
324 static GLboolean
325 _mesa_texstore_z24_s8(TEXSTORE_PARAMS)
326 {
327 const GLuint depthScale = 0xffffff;
328 const GLint srcRowStride
329 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
330 GLint img, row;
331 GLuint *depth = malloc(srcWidth * sizeof(GLuint));
332 GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
333
334 assert(dstFormat == MESA_FORMAT_S8_UINT_Z24_UNORM);
335 assert(srcFormat == GL_DEPTH_STENCIL_EXT ||
336 srcFormat == GL_DEPTH_COMPONENT ||
337 srcFormat == GL_STENCIL_INDEX);
338 assert(srcFormat != GL_DEPTH_STENCIL_EXT ||
339 srcType == GL_UNSIGNED_INT_24_8_EXT ||
340 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
341
342 if (!depth || !stencil) {
343 free(depth);
344 free(stencil);
345 return GL_FALSE;
346 }
347
348 /* In case we only upload depth we need to preserve the stencil */
349 for (img = 0; img < srcDepth; img++) {
350 GLuint *dstRow = (GLuint *) dstSlices[img];
351 const GLubyte *src
352 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
353 srcWidth, srcHeight,
354 srcFormat, srcType,
355 img, 0, 0);
356 for (row = 0; row < srcHeight; row++) {
357 GLint i;
358 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
359
360 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
361 keepstencil = GL_TRUE;
362 }
363 else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
364 keepdepth = GL_TRUE;
365 }
366
367 if (keepdepth == GL_FALSE)
368 /* the 24 depth bits will be in the low position: */
369 _mesa_unpack_depth_span(ctx, srcWidth,
370 GL_UNSIGNED_INT, /* dst type */
371 keepstencil ? depth : dstRow, /* dst addr */
372 depthScale,
373 srcType, src, srcPacking);
374
375 if (keepstencil == GL_FALSE)
376 /* get the 8-bit stencil values */
377 _mesa_unpack_stencil_span(ctx, srcWidth,
378 GL_UNSIGNED_BYTE, /* dst type */
379 stencil, /* dst addr */
380 srcType, src, srcPacking,
381 ctx->_ImageTransferState);
382
383 for (i = 0; i < srcWidth; i++) {
384 if (keepstencil)
385 dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
386 else
387 dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);
388 }
389 src += srcRowStride;
390 dstRow += dstRowStride / sizeof(GLuint);
391 }
392 }
393
394 free(depth);
395 free(stencil);
396 return GL_TRUE;
397 }
398
399
400 /**
401 * Store a combined depth/stencil texture image.
402 */
403 static GLboolean
404 _mesa_texstore_s8_z24(TEXSTORE_PARAMS)
405 {
406 const GLuint depthScale = 0xffffff;
407 const GLint srcRowStride
408 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
409 GLint img, row;
410 GLuint *depth;
411 GLubyte *stencil;
412
413 assert(dstFormat == MESA_FORMAT_Z24_UNORM_S8_UINT);
414 assert(srcFormat == GL_DEPTH_STENCIL_EXT ||
415 srcFormat == GL_DEPTH_COMPONENT ||
416 srcFormat == GL_STENCIL_INDEX);
417 assert(srcFormat != GL_DEPTH_STENCIL_EXT ||
418 srcType == GL_UNSIGNED_INT_24_8_EXT ||
419 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
420
421 depth = malloc(srcWidth * sizeof(GLuint));
422 stencil = malloc(srcWidth * sizeof(GLubyte));
423
424 if (!depth || !stencil) {
425 free(depth);
426 free(stencil);
427 return GL_FALSE;
428 }
429
430 for (img = 0; img < srcDepth; img++) {
431 GLuint *dstRow = (GLuint *) dstSlices[img];
432 const GLubyte *src
433 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
434 srcWidth, srcHeight,
435 srcFormat, srcType,
436 img, 0, 0);
437 for (row = 0; row < srcHeight; row++) {
438 GLint i;
439 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
440
441 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
442 keepstencil = GL_TRUE;
443 }
444 else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
445 keepdepth = GL_TRUE;
446 }
447
448 if (keepdepth == GL_FALSE)
449 /* the 24 depth bits will be in the low position: */
450 _mesa_unpack_depth_span(ctx, srcWidth,
451 GL_UNSIGNED_INT, /* dst type */
452 keepstencil ? depth : dstRow, /* dst addr */
453 depthScale,
454 srcType, src, srcPacking);
455
456 if (keepstencil == GL_FALSE)
457 /* get the 8-bit stencil values */
458 _mesa_unpack_stencil_span(ctx, srcWidth,
459 GL_UNSIGNED_BYTE, /* dst type */
460 stencil, /* dst addr */
461 srcType, src, srcPacking,
462 ctx->_ImageTransferState);
463
464 /* merge stencil values into depth values */
465 for (i = 0; i < srcWidth; i++) {
466 if (keepstencil)
467 dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);
468 else
469 dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);
470
471 }
472 src += srcRowStride;
473 dstRow += dstRowStride / sizeof(GLuint);
474 }
475 }
476
477 free(depth);
478 free(stencil);
479
480 return GL_TRUE;
481 }
482
483
484 /**
485 * Store simple 8-bit/value stencil texture data.
486 */
487 static GLboolean
488 _mesa_texstore_s8(TEXSTORE_PARAMS)
489 {
490 assert(dstFormat == MESA_FORMAT_S_UINT8);
491 assert(srcFormat == GL_STENCIL_INDEX);
492
493 {
494 const GLint srcRowStride
495 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
496 GLint img, row;
497 GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
498
499 if (!stencil)
500 return GL_FALSE;
501
502 for (img = 0; img < srcDepth; img++) {
503 GLubyte *dstRow = dstSlices[img];
504 const GLubyte *src
505 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
506 srcWidth, srcHeight,
507 srcFormat, srcType,
508 img, 0, 0);
509 for (row = 0; row < srcHeight; row++) {
510 GLint i;
511
512 /* get the 8-bit stencil values */
513 _mesa_unpack_stencil_span(ctx, srcWidth,
514 GL_UNSIGNED_BYTE, /* dst type */
515 stencil, /* dst addr */
516 srcType, src, srcPacking,
517 ctx->_ImageTransferState);
518 /* merge stencil values into depth values */
519 for (i = 0; i < srcWidth; i++)
520 dstRow[i] = stencil[i];
521
522 src += srcRowStride;
523 dstRow += dstRowStride / sizeof(GLubyte);
524 }
525 }
526
527 free(stencil);
528 }
529
530 return GL_TRUE;
531 }
532
533
534 static GLboolean
535 _mesa_texstore_z32f_x24s8(TEXSTORE_PARAMS)
536 {
537 GLint img, row;
538 const GLint srcRowStride
539 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
540 / sizeof(uint64_t);
541
542 assert(dstFormat == MESA_FORMAT_Z32_FLOAT_S8X24_UINT);
543 assert(srcFormat == GL_DEPTH_STENCIL ||
544 srcFormat == GL_DEPTH_COMPONENT ||
545 srcFormat == GL_STENCIL_INDEX);
546 assert(srcFormat != GL_DEPTH_STENCIL ||
547 srcType == GL_UNSIGNED_INT_24_8 ||
548 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
549
550 /* In case we only upload depth we need to preserve the stencil */
551 for (img = 0; img < srcDepth; img++) {
552 uint64_t *dstRow = (uint64_t *) dstSlices[img];
553 const uint64_t *src
554 = (const uint64_t *) _mesa_image_address(dims, srcPacking, srcAddr,
555 srcWidth, srcHeight,
556 srcFormat, srcType,
557 img, 0, 0);
558 for (row = 0; row < srcHeight; row++) {
559 /* The unpack functions with:
560 * dstType = GL_FLOAT_32_UNSIGNED_INT_24_8_REV
561 * only write their own dword, so the other dword (stencil
562 * or depth) is preserved. */
563 if (srcFormat != GL_STENCIL_INDEX)
564 _mesa_unpack_depth_span(ctx, srcWidth,
565 GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
566 dstRow, /* dst addr */
567 ~0U, srcType, src, srcPacking);
568
569 if (srcFormat != GL_DEPTH_COMPONENT)
570 _mesa_unpack_stencil_span(ctx, srcWidth,
571 GL_FLOAT_32_UNSIGNED_INT_24_8_REV, /* dst type */
572 dstRow, /* dst addr */
573 srcType, src, srcPacking,
574 ctx->_ImageTransferState);
575
576 src += srcRowStride;
577 dstRow += dstRowStride / sizeof(uint64_t);
578 }
579 }
580 return GL_TRUE;
581 }
582
583 static GLboolean
584 texstore_depth_stencil(TEXSTORE_PARAMS)
585 {
586 static StoreTexImageFunc table[MESA_FORMAT_COUNT];
587 static GLboolean initialized = GL_FALSE;
588
589 if (!initialized) {
590 memset(table, 0, sizeof table);
591
592 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = _mesa_texstore_z24_s8;
593 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = _mesa_texstore_s8_z24;
594 table[MESA_FORMAT_Z_UNORM16] = _mesa_texstore_z16;
595 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = _mesa_texstore_x8_z24;
596 table[MESA_FORMAT_X8_UINT_Z24_UNORM] = _mesa_texstore_z24_x8;
597 table[MESA_FORMAT_Z_UNORM32] = _mesa_texstore_z32;
598 table[MESA_FORMAT_S_UINT8] = _mesa_texstore_s8;
599 table[MESA_FORMAT_Z_FLOAT32] = _mesa_texstore_z32;
600 table[MESA_FORMAT_Z32_FLOAT_S8X24_UINT] = _mesa_texstore_z32f_x24s8;
601
602 initialized = GL_TRUE;
603 }
604
605 assert(table[dstFormat]);
606 return table[dstFormat](ctx, dims, baseInternalFormat,
607 dstFormat, dstRowStride, dstSlices,
608 srcWidth, srcHeight, srcDepth,
609 srcFormat, srcType, srcAddr, srcPacking);
610 }
611
612 static GLboolean
613 texstore_compressed(TEXSTORE_PARAMS)
614 {
615 static StoreTexImageFunc table[MESA_FORMAT_COUNT];
616 static GLboolean initialized = GL_FALSE;
617
618 if (!initialized) {
619 memset(table, 0, sizeof table);
620
621 table[MESA_FORMAT_SRGB_DXT1] = _mesa_texstore_rgb_dxt1;
622 table[MESA_FORMAT_SRGBA_DXT1] = _mesa_texstore_rgba_dxt1;
623 table[MESA_FORMAT_SRGBA_DXT3] = _mesa_texstore_rgba_dxt3;
624 table[MESA_FORMAT_SRGBA_DXT5] = _mesa_texstore_rgba_dxt5;
625 table[MESA_FORMAT_RGB_FXT1] = _mesa_texstore_rgb_fxt1;
626 table[MESA_FORMAT_RGBA_FXT1] = _mesa_texstore_rgba_fxt1;
627 table[MESA_FORMAT_RGB_DXT1] = _mesa_texstore_rgb_dxt1;
628 table[MESA_FORMAT_RGBA_DXT1] = _mesa_texstore_rgba_dxt1;
629 table[MESA_FORMAT_RGBA_DXT3] = _mesa_texstore_rgba_dxt3;
630 table[MESA_FORMAT_RGBA_DXT5] = _mesa_texstore_rgba_dxt5;
631 table[MESA_FORMAT_R_RGTC1_UNORM] = _mesa_texstore_red_rgtc1;
632 table[MESA_FORMAT_R_RGTC1_SNORM] = _mesa_texstore_signed_red_rgtc1;
633 table[MESA_FORMAT_RG_RGTC2_UNORM] = _mesa_texstore_rg_rgtc2;
634 table[MESA_FORMAT_RG_RGTC2_SNORM] = _mesa_texstore_signed_rg_rgtc2;
635 table[MESA_FORMAT_L_LATC1_UNORM] = _mesa_texstore_red_rgtc1;
636 table[MESA_FORMAT_L_LATC1_SNORM] = _mesa_texstore_signed_red_rgtc1;
637 table[MESA_FORMAT_LA_LATC2_UNORM] = _mesa_texstore_rg_rgtc2;
638 table[MESA_FORMAT_LA_LATC2_SNORM] = _mesa_texstore_signed_rg_rgtc2;
639 table[MESA_FORMAT_ETC1_RGB8] = _mesa_texstore_etc1_rgb8;
640 table[MESA_FORMAT_ETC2_RGB8] = _mesa_texstore_etc2_rgb8;
641 table[MESA_FORMAT_ETC2_SRGB8] = _mesa_texstore_etc2_srgb8;
642 table[MESA_FORMAT_ETC2_RGBA8_EAC] = _mesa_texstore_etc2_rgba8_eac;
643 table[MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC] = _mesa_texstore_etc2_srgb8_alpha8_eac;
644 table[MESA_FORMAT_ETC2_R11_EAC] = _mesa_texstore_etc2_r11_eac;
645 table[MESA_FORMAT_ETC2_RG11_EAC] = _mesa_texstore_etc2_rg11_eac;
646 table[MESA_FORMAT_ETC2_SIGNED_R11_EAC] = _mesa_texstore_etc2_signed_r11_eac;
647 table[MESA_FORMAT_ETC2_SIGNED_RG11_EAC] = _mesa_texstore_etc2_signed_rg11_eac;
648 table[MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1] =
649 _mesa_texstore_etc2_rgb8_punchthrough_alpha1;
650 table[MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1] =
651 _mesa_texstore_etc2_srgb8_punchthrough_alpha1;
652
653 table[MESA_FORMAT_BPTC_RGBA_UNORM] =
654 _mesa_texstore_bptc_rgba_unorm;
655 table[MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM] =
656 _mesa_texstore_bptc_rgba_unorm;
657 table[MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT] =
658 _mesa_texstore_bptc_rgb_signed_float;
659 table[MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT] =
660 _mesa_texstore_bptc_rgb_unsigned_float;
661
662 initialized = GL_TRUE;
663 }
664
665 assert(table[dstFormat]);
666 return table[dstFormat](ctx, dims, baseInternalFormat,
667 dstFormat, dstRowStride, dstSlices,
668 srcWidth, srcHeight, srcDepth,
669 srcFormat, srcType, srcAddr, srcPacking);
670 }
671
672 static GLboolean
673 texstore_rgba(TEXSTORE_PARAMS)
674 {
675 void *tempImage = NULL, *tempRGBA = NULL;
676 int srcRowStride, img;
677 GLubyte *src, *dst;
678 uint32_t srcMesaFormat;
679 uint8_t rebaseSwizzle[4];
680 bool needRebase;
681 bool transferOpsDone = false;
682
683 /* We have to handle MESA_FORMAT_YCBCR manually because it is a special case
684 * and _mesa_format_convert does not support it. In this case the we only
685 * allow conversions between YCBCR formats and it is mostly a memcpy.
686 */
687 if (dstFormat == MESA_FORMAT_YCBCR || dstFormat == MESA_FORMAT_YCBCR_REV) {
688 return _mesa_texstore_ycbcr(ctx, dims, baseInternalFormat,
689 dstFormat, dstRowStride, dstSlices,
690 srcWidth, srcHeight, srcDepth,
691 srcFormat, srcType, srcAddr,
692 srcPacking);
693 }
694
695 /* We have to deal with GL_COLOR_INDEX manually because
696 * _mesa_format_convert does not handle this format. So what we do here is
697 * convert it to RGBA ubyte first and then convert from that to dst as usual.
698 */
699 if (srcFormat == GL_COLOR_INDEX) {
700 /* Notice that this will already handle byte swapping if necessary */
701 tempImage =
702 _mesa_unpack_color_index_to_rgba_ubyte(ctx, dims,
703 srcAddr, srcFormat, srcType,
704 srcWidth, srcHeight, srcDepth,
705 srcPacking,
706 ctx->_ImageTransferState);
707 if (!tempImage)
708 return GL_FALSE;
709
710 /* _mesa_unpack_color_index_to_rgba_ubyte has handled transferops
711 * if needed.
712 */
713 transferOpsDone = true;
714
715 /* Now we only have to adjust our src info for a conversion from
716 * the RGBA ubyte and then we continue as usual.
717 */
718 srcAddr = tempImage;
719 srcFormat = GL_RGBA;
720 srcType = GL_UNSIGNED_BYTE;
721 } else if (srcPacking->SwapBytes) {
722 /* We have to handle byte-swapping scenarios before calling
723 * _mesa_format_convert
724 */
725 GLint swapSize = _mesa_sizeof_packed_type(srcType);
726 if (swapSize == 2 || swapSize == 4) {
727 int imageStride = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat, srcType);
728 int bufferSize = imageStride * srcDepth;
729 int layer;
730 const uint8_t *src;
731 uint8_t *dst;
732
733 tempImage = malloc(bufferSize);
734 if (!tempImage)
735 return GL_FALSE;
736 src = srcAddr;
737 dst = tempImage;
738 for (layer = 0; layer < srcDepth; layer++) {
739 _mesa_swap_bytes_2d_image(srcFormat, srcType,
740 srcPacking,
741 srcWidth, srcHeight,
742 dst, src);
743 src += imageStride;
744 dst += imageStride;
745 }
746 srcAddr = tempImage;
747 }
748 }
749
750 srcRowStride =
751 _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
752
753 srcMesaFormat = _mesa_format_from_format_and_type(srcFormat, srcType);
754 dstFormat = _mesa_get_srgb_format_linear(dstFormat);
755
756 /* If we have transferOps then we need to convert to RGBA float first,
757 then apply transferOps, then do the conversion to dst
758 */
759 if (!transferOpsDone &&
760 _mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat)) {
761 /* Allocate RGBA float image */
762 int elementCount = srcWidth * srcHeight * srcDepth;
763 tempRGBA = malloc(4 * elementCount * sizeof(float));
764 if (!tempRGBA) {
765 free(tempImage);
766 free(tempRGBA);
767 return GL_FALSE;
768 }
769
770 /* Convert from src to RGBA float */
771 src = (GLubyte *) srcAddr;
772 dst = (GLubyte *) tempRGBA;
773 for (img = 0; img < srcDepth; img++) {
774 _mesa_format_convert(dst, RGBA32_FLOAT, 4 * srcWidth * sizeof(float),
775 src, srcMesaFormat, srcRowStride,
776 srcWidth, srcHeight, NULL);
777 src += srcHeight * srcRowStride;
778 dst += srcHeight * 4 * srcWidth * sizeof(float);
779 }
780
781 /* Apply transferOps */
782 _mesa_apply_rgba_transfer_ops(ctx, ctx->_ImageTransferState, elementCount,
783 (float(*)[4]) tempRGBA);
784
785 /* Now we have to adjust our src info for a conversion from
786 * the RGBA float image and then we continue as usual.
787 */
788 srcAddr = tempRGBA;
789 srcFormat = GL_RGBA;
790 srcType = GL_FLOAT;
791 srcRowStride = srcWidth * 4 * sizeof(float);
792 srcMesaFormat = RGBA32_FLOAT;
793 srcPacking = &ctx->DefaultPacking;
794 }
795
796 src = (GLubyte *)
797 _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
798 srcFormat, srcType, 0, 0, 0);
799
800 if (_mesa_get_format_base_format(dstFormat) != baseInternalFormat) {
801 needRebase =
802 _mesa_compute_rgba2base2rgba_component_mapping(baseInternalFormat,
803 rebaseSwizzle);
804 } else {
805 needRebase = false;
806 }
807
808 for (img = 0; img < srcDepth; img++) {
809 _mesa_format_convert(dstSlices[img], dstFormat, dstRowStride,
810 src, srcMesaFormat, srcRowStride,
811 srcWidth, srcHeight,
812 needRebase ? rebaseSwizzle : NULL);
813 src += srcHeight * srcRowStride;
814 }
815
816 free(tempImage);
817 free(tempRGBA);
818
819 return GL_TRUE;
820 }
821
822 GLboolean
823 _mesa_texstore_needs_transfer_ops(struct gl_context *ctx,
824 GLenum baseInternalFormat,
825 mesa_format dstFormat)
826 {
827 GLenum dstType;
828
829 /* There are different rules depending on the base format. */
830 switch (baseInternalFormat) {
831 case GL_DEPTH_COMPONENT:
832 case GL_DEPTH_STENCIL:
833 return ctx->Pixel.DepthScale != 1.0f ||
834 ctx->Pixel.DepthBias != 0.0f;
835
836 case GL_STENCIL_INDEX:
837 return GL_FALSE;
838
839 default:
840 /* Color formats.
841 * Pixel transfer ops (scale, bias, table lookup) do not apply
842 * to integer formats.
843 */
844 dstType = _mesa_get_format_datatype(dstFormat);
845
846 return dstType != GL_INT && dstType != GL_UNSIGNED_INT &&
847 ctx->_ImageTransferState;
848 }
849 }
850
851
852 GLboolean
853 _mesa_texstore_can_use_memcpy(struct gl_context *ctx,
854 GLenum baseInternalFormat, mesa_format dstFormat,
855 GLenum srcFormat, GLenum srcType,
856 const struct gl_pixelstore_attrib *srcPacking)
857 {
858 if (_mesa_texstore_needs_transfer_ops(ctx, baseInternalFormat, dstFormat)) {
859 return GL_FALSE;
860 }
861
862 /* The base internal format and the base Mesa format must match. */
863 if (baseInternalFormat != _mesa_get_format_base_format(dstFormat)) {
864 return GL_FALSE;
865 }
866
867 /* The Mesa format must match the input format and type. */
868 if (!_mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
869 srcPacking->SwapBytes, NULL)) {
870 return GL_FALSE;
871 }
872
873 /* Depth texture data needs clamping in following cases:
874 * - Floating point dstFormat with signed srcType: clamp to [0.0, 1.0].
875 * - Fixed point dstFormat with signed srcType: clamp to [0, 2^n -1].
876 *
877 * All the cases except one (float dstFormat with float srcType) are ruled
878 * out by _mesa_format_matches_format_and_type() check above. Handle the
879 * remaining case here.
880 */
881 if ((baseInternalFormat == GL_DEPTH_COMPONENT ||
882 baseInternalFormat == GL_DEPTH_STENCIL) &&
883 (srcType == GL_FLOAT ||
884 srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)) {
885 return GL_FALSE;
886 }
887
888 return GL_TRUE;
889 }
890
891 static GLboolean
892 _mesa_texstore_memcpy(TEXSTORE_PARAMS)
893 {
894 if (!_mesa_texstore_can_use_memcpy(ctx, baseInternalFormat, dstFormat,
895 srcFormat, srcType, srcPacking)) {
896 return GL_FALSE;
897 }
898
899 _mesa_memcpy_texture(ctx, dims,
900 dstFormat,
901 dstRowStride, dstSlices,
902 srcWidth, srcHeight, srcDepth, srcFormat, srcType,
903 srcAddr, srcPacking);
904 return GL_TRUE;
905 }
906
907
908 /**
909 * Store user data into texture memory.
910 * Called via glTex[Sub]Image1/2/3D()
911 * \return GL_TRUE for success, GL_FALSE for failure (out of memory).
912 */
913 GLboolean
914 _mesa_texstore(TEXSTORE_PARAMS)
915 {
916 if (_mesa_texstore_memcpy(ctx, dims, baseInternalFormat,
917 dstFormat,
918 dstRowStride, dstSlices,
919 srcWidth, srcHeight, srcDepth,
920 srcFormat, srcType, srcAddr, srcPacking)) {
921 return GL_TRUE;
922 }
923
924 if (_mesa_is_depth_or_stencil_format(baseInternalFormat)) {
925 return texstore_depth_stencil(ctx, dims, baseInternalFormat,
926 dstFormat, dstRowStride, dstSlices,
927 srcWidth, srcHeight, srcDepth,
928 srcFormat, srcType, srcAddr, srcPacking);
929 } else if (_mesa_is_format_compressed(dstFormat)) {
930 return texstore_compressed(ctx, dims, baseInternalFormat,
931 dstFormat, dstRowStride, dstSlices,
932 srcWidth, srcHeight, srcDepth,
933 srcFormat, srcType, srcAddr, srcPacking);
934 } else {
935 return texstore_rgba(ctx, dims, baseInternalFormat,
936 dstFormat, dstRowStride, dstSlices,
937 srcWidth, srcHeight, srcDepth,
938 srcFormat, srcType, srcAddr, srcPacking);
939 }
940 }
941
942
943 /**
944 * Normally, we'll only _write_ texel data to a texture when we map it.
945 * But if the user is providing depth or stencil values and the texture
946 * image is a combined depth/stencil format, we'll actually read from
947 * the texture buffer too (in order to insert the depth or stencil values.
948 * \param userFormat the user-provided image format
949 * \param texFormat the destination texture format
950 */
951 static GLbitfield
952 get_read_write_mode(GLenum userFormat, mesa_format texFormat)
953 {
954 if ((userFormat == GL_STENCIL_INDEX || userFormat == GL_DEPTH_COMPONENT)
955 && _mesa_get_format_base_format(texFormat) == GL_DEPTH_STENCIL)
956 return GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
957 else
958 return GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
959 }
960
961
962 /**
963 * Helper function for storing 1D, 2D, 3D whole and subimages into texture
964 * memory.
965 * The source of the image data may be user memory or a PBO. In the later
966 * case, we'll map the PBO, copy from it, then unmap it.
967 */
968 static void
969 store_texsubimage(struct gl_context *ctx,
970 struct gl_texture_image *texImage,
971 GLint xoffset, GLint yoffset, GLint zoffset,
972 GLint width, GLint height, GLint depth,
973 GLenum format, GLenum type, const GLvoid *pixels,
974 const struct gl_pixelstore_attrib *packing,
975 const char *caller)
976
977 {
978 const GLbitfield mapMode = get_read_write_mode(format, texImage->TexFormat);
979 const GLenum target = texImage->TexObject->Target;
980 GLboolean success = GL_FALSE;
981 GLuint dims, slice, numSlices = 1, sliceOffset = 0;
982 GLint srcImageStride = 0;
983 const GLubyte *src;
984
985 assert(xoffset + width <= texImage->Width);
986 assert(yoffset + height <= texImage->Height);
987 assert(zoffset + depth <= texImage->Depth);
988
989 switch (target) {
990 case GL_TEXTURE_1D:
991 dims = 1;
992 break;
993 case GL_TEXTURE_2D_ARRAY:
994 case GL_TEXTURE_CUBE_MAP_ARRAY:
995 case GL_TEXTURE_3D:
996 dims = 3;
997 break;
998 default:
999 dims = 2;
1000 }
1001
1002 /* get pointer to src pixels (may be in a pbo which we'll map here) */
1003 src = (const GLubyte *)
1004 _mesa_validate_pbo_teximage(ctx, dims, width, height, depth,
1005 format, type, pixels, packing, caller);
1006 if (!src)
1007 return;
1008
1009 /* compute slice info (and do some sanity checks) */
1010 switch (target) {
1011 case GL_TEXTURE_2D:
1012 case GL_TEXTURE_2D_MULTISAMPLE:
1013 case GL_TEXTURE_RECTANGLE:
1014 case GL_TEXTURE_CUBE_MAP:
1015 case GL_TEXTURE_EXTERNAL_OES:
1016 /* one image slice, nothing special needs to be done */
1017 break;
1018 case GL_TEXTURE_1D:
1019 assert(height == 1);
1020 assert(depth == 1);
1021 assert(yoffset == 0);
1022 assert(zoffset == 0);
1023 break;
1024 case GL_TEXTURE_1D_ARRAY:
1025 assert(depth == 1);
1026 assert(zoffset == 0);
1027 numSlices = height;
1028 sliceOffset = yoffset;
1029 height = 1;
1030 yoffset = 0;
1031 srcImageStride = _mesa_image_row_stride(packing, width, format, type);
1032 break;
1033 case GL_TEXTURE_2D_ARRAY:
1034 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
1035 numSlices = depth;
1036 sliceOffset = zoffset;
1037 depth = 1;
1038 zoffset = 0;
1039 srcImageStride = _mesa_image_image_stride(packing, width, height,
1040 format, type);
1041 break;
1042 case GL_TEXTURE_3D:
1043 /* we'll store 3D images as a series of slices */
1044 numSlices = depth;
1045 sliceOffset = zoffset;
1046 srcImageStride = _mesa_image_image_stride(packing, width, height,
1047 format, type);
1048 break;
1049 case GL_TEXTURE_CUBE_MAP_ARRAY:
1050 numSlices = depth;
1051 sliceOffset = zoffset;
1052 srcImageStride = _mesa_image_image_stride(packing, width, height,
1053 format, type);
1054 break;
1055 default:
1056 _mesa_warning(ctx, "Unexpected target 0x%x in store_texsubimage()", target);
1057 return;
1058 }
1059
1060 assert(numSlices == 1 || srcImageStride != 0);
1061
1062 for (slice = 0; slice < numSlices; slice++) {
1063 GLubyte *dstMap;
1064 GLint dstRowStride;
1065
1066 ctx->Driver.MapTextureImage(ctx, texImage,
1067 slice + sliceOffset,
1068 xoffset, yoffset, width, height,
1069 mapMode, &dstMap, &dstRowStride);
1070 if (dstMap) {
1071 /* Note: we're only storing a 2D (or 1D) slice at a time but we need
1072 * to pass the right 'dims' value so that GL_UNPACK_SKIP_IMAGES is
1073 * used for 3D images.
1074 */
1075 success = _mesa_texstore(ctx, dims, texImage->_BaseFormat,
1076 texImage->TexFormat,
1077 dstRowStride,
1078 &dstMap,
1079 width, height, 1, /* w, h, d */
1080 format, type, src, packing);
1081
1082 ctx->Driver.UnmapTextureImage(ctx, texImage, slice + sliceOffset);
1083 }
1084
1085 src += srcImageStride;
1086
1087 if (!success)
1088 break;
1089 }
1090
1091 if (!success)
1092 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", caller);
1093
1094 _mesa_unmap_teximage_pbo(ctx, packing);
1095 }
1096
1097
1098
1099 /**
1100 * Fallback code for ctx->Driver.TexImage().
1101 * Basically, allocate storage for the texture image, then copy the
1102 * user's image into it.
1103 */
1104 void
1105 _mesa_store_teximage(struct gl_context *ctx,
1106 GLuint dims,
1107 struct gl_texture_image *texImage,
1108 GLenum format, GLenum type, const GLvoid *pixels,
1109 const struct gl_pixelstore_attrib *packing)
1110 {
1111 assert(dims == 1 || dims == 2 || dims == 3);
1112
1113 if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
1114 return;
1115
1116 /* allocate storage for texture data */
1117 if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
1118 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
1119 return;
1120 }
1121
1122 store_texsubimage(ctx, texImage,
1123 0, 0, 0, texImage->Width, texImage->Height, texImage->Depth,
1124 format, type, pixels, packing, "glTexImage");
1125 }
1126
1127
1128 /*
1129 * Fallback for Driver.TexSubImage().
1130 */
1131 void
1132 _mesa_store_texsubimage(struct gl_context *ctx, GLuint dims,
1133 struct gl_texture_image *texImage,
1134 GLint xoffset, GLint yoffset, GLint zoffset,
1135 GLint width, GLint height, GLint depth,
1136 GLenum format, GLenum type, const void *pixels,
1137 const struct gl_pixelstore_attrib *packing)
1138 {
1139 store_texsubimage(ctx, texImage,
1140 xoffset, yoffset, zoffset, width, height, depth,
1141 format, type, pixels, packing, "glTexSubImage");
1142 }
1143
1144 static void
1145 clear_image_to_zero(GLubyte *dstMap, GLint dstRowStride,
1146 GLsizei width, GLsizei height,
1147 GLsizei clearValueSize)
1148 {
1149 GLsizei y;
1150
1151 for (y = 0; y < height; y++) {
1152 memset(dstMap, 0, clearValueSize * width);
1153 dstMap += dstRowStride;
1154 }
1155 }
1156
1157 static void
1158 clear_image_to_value(GLubyte *dstMap, GLint dstRowStride,
1159 GLsizei width, GLsizei height,
1160 const GLvoid *clearValue,
1161 GLsizei clearValueSize)
1162 {
1163 GLsizei y, x;
1164
1165 for (y = 0; y < height; y++) {
1166 for (x = 0; x < width; x++) {
1167 memcpy(dstMap, clearValue, clearValueSize);
1168 dstMap += clearValueSize;
1169 }
1170 dstMap += dstRowStride - clearValueSize * width;
1171 }
1172 }
1173
1174 /*
1175 * Fallback for Driver.ClearTexSubImage().
1176 */
1177 void
1178 _mesa_store_cleartexsubimage(struct gl_context *ctx,
1179 struct gl_texture_image *texImage,
1180 GLint xoffset, GLint yoffset, GLint zoffset,
1181 GLsizei width, GLsizei height, GLsizei depth,
1182 const GLvoid *clearValue)
1183 {
1184 GLubyte *dstMap;
1185 GLint dstRowStride;
1186 GLsizeiptr clearValueSize;
1187 GLsizei z;
1188
1189 clearValueSize = _mesa_get_format_bytes(texImage->TexFormat);
1190
1191 for (z = 0; z < depth; z++) {
1192 ctx->Driver.MapTextureImage(ctx, texImage,
1193 z + zoffset, xoffset, yoffset,
1194 width, height,
1195 GL_MAP_WRITE_BIT,
1196 &dstMap, &dstRowStride);
1197 if (dstMap == NULL) {
1198 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClearTex*Image");
1199 return;
1200 }
1201
1202 if (clearValue) {
1203 clear_image_to_value(dstMap, dstRowStride,
1204 width, height,
1205 clearValue,
1206 clearValueSize);
1207 } else {
1208 clear_image_to_zero(dstMap, dstRowStride,
1209 width, height,
1210 clearValueSize);
1211 }
1212
1213 ctx->Driver.UnmapTextureImage(ctx, texImage, z + zoffset);
1214 }
1215 }
1216
1217 /**
1218 * Fallback for Driver.CompressedTexImage()
1219 */
1220 void
1221 _mesa_store_compressed_teximage(struct gl_context *ctx, GLuint dims,
1222 struct gl_texture_image *texImage,
1223 GLsizei imageSize, const GLvoid *data)
1224 {
1225 /* only 2D and 3D compressed images are supported at this time */
1226 if (dims == 1) {
1227 _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call");
1228 return;
1229 }
1230
1231 /* This is pretty simple, because unlike the general texstore path we don't
1232 * have to worry about the usual image unpacking or image transfer
1233 * operations.
1234 */
1235 assert(texImage);
1236 assert(texImage->Width > 0);
1237 assert(texImage->Height > 0);
1238 assert(texImage->Depth > 0);
1239
1240 /* allocate storage for texture data */
1241 if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) {
1242 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims);
1243 return;
1244 }
1245
1246 ctx->Driver.CompressedTexSubImage(ctx, dims, texImage,
1247 0, 0, 0,
1248 texImage->Width, texImage->Height, texImage->Depth,
1249 texImage->TexFormat,
1250 imageSize, data);
1251 }
1252
1253
1254 /**
1255 * Compute compressed_pixelstore parameters for copying compressed
1256 * texture data.
1257 * \param dims number of texture image dimensions: 1, 2 or 3
1258 * \param texFormat the compressed texture format
1259 * \param width, height, depth size of image to copy
1260 * \param packing pixelstore parameters describing user-space image packing
1261 * \param store returns the compressed_pixelstore parameters
1262 */
1263 void
1264 _mesa_compute_compressed_pixelstore(GLuint dims, mesa_format texFormat,
1265 GLsizei width, GLsizei height,
1266 GLsizei depth,
1267 const struct gl_pixelstore_attrib *packing,
1268 struct compressed_pixelstore *store)
1269 {
1270 GLuint bw, bh, bd;
1271
1272 _mesa_get_format_block_size_3d(texFormat, &bw, &bh, &bd);
1273
1274 store->SkipBytes = 0;
1275 store->TotalBytesPerRow = store->CopyBytesPerRow =
1276 _mesa_format_row_stride(texFormat, width);
1277 store->TotalRowsPerSlice = store->CopyRowsPerSlice =
1278 (height + bh - 1) / bh;
1279 store->CopySlices = (depth + bd - 1) / bd;
1280
1281 if (packing->CompressedBlockWidth &&
1282 packing->CompressedBlockSize) {
1283
1284 bw = packing->CompressedBlockWidth;
1285
1286 if (packing->RowLength) {
1287 store->TotalBytesPerRow = packing->CompressedBlockSize *
1288 ((packing->RowLength + bw - 1) / bw);
1289 }
1290
1291 store->SkipBytes += packing->SkipPixels * packing->CompressedBlockSize / bw;
1292 }
1293
1294 if (dims > 1 && packing->CompressedBlockHeight &&
1295 packing->CompressedBlockSize) {
1296
1297 bh = packing->CompressedBlockHeight;
1298
1299 store->SkipBytes += packing->SkipRows * store->TotalBytesPerRow / bh;
1300 store->CopyRowsPerSlice = (height + bh - 1) / bh; /* rows in blocks */
1301
1302 if (packing->ImageHeight) {
1303 store->TotalRowsPerSlice = (packing->ImageHeight + bh - 1) / bh;
1304 }
1305 }
1306
1307 if (dims > 2 && packing->CompressedBlockDepth &&
1308 packing->CompressedBlockSize) {
1309
1310 int bd = packing->CompressedBlockDepth;
1311
1312 store->SkipBytes += packing->SkipImages * store->TotalBytesPerRow *
1313 store->TotalRowsPerSlice / bd;
1314 }
1315 }
1316
1317
1318 /**
1319 * Fallback for Driver.CompressedTexSubImage()
1320 */
1321 void
1322 _mesa_store_compressed_texsubimage(struct gl_context *ctx, GLuint dims,
1323 struct gl_texture_image *texImage,
1324 GLint xoffset, GLint yoffset, GLint zoffset,
1325 GLsizei width, GLsizei height, GLsizei depth,
1326 GLenum format,
1327 GLsizei imageSize, const GLvoid *data)
1328 {
1329 struct compressed_pixelstore store;
1330 GLint dstRowStride;
1331 GLint i, slice;
1332 GLubyte *dstMap;
1333 const GLubyte *src;
1334
1335 if (dims == 1) {
1336 _mesa_problem(ctx, "Unexpected 1D compressed texsubimage call");
1337 return;
1338 }
1339
1340 _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat,
1341 width, height, depth,
1342 &ctx->Unpack, &store);
1343
1344 /* get pointer to src pixels (may be in a pbo which we'll map here) */
1345 data = _mesa_validate_pbo_compressed_teximage(ctx, dims, imageSize, data,
1346 &ctx->Unpack,
1347 "glCompressedTexSubImage");
1348 if (!data)
1349 return;
1350
1351 src = (const GLubyte *) data + store.SkipBytes;
1352
1353 for (slice = 0; slice < store.CopySlices; slice++) {
1354 /* Map dest texture buffer */
1355 ctx->Driver.MapTextureImage(ctx, texImage, slice + zoffset,
1356 xoffset, yoffset, width, height,
1357 GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
1358 &dstMap, &dstRowStride);
1359
1360 if (dstMap) {
1361
1362 /* copy rows of blocks */
1363 if (dstRowStride == store.TotalBytesPerRow &&
1364 dstRowStride == store.CopyBytesPerRow) {
1365 memcpy(dstMap, src, store.CopyBytesPerRow * store.CopyRowsPerSlice);
1366 src += store.CopyBytesPerRow * store.CopyRowsPerSlice;
1367 }
1368 else {
1369 for (i = 0; i < store.CopyRowsPerSlice; i++) {
1370 memcpy(dstMap, src, store.CopyBytesPerRow);
1371 dstMap += dstRowStride;
1372 src += store.TotalBytesPerRow;
1373 }
1374 }
1375
1376 ctx->Driver.UnmapTextureImage(ctx, texImage, slice + zoffset);
1377
1378 /* advance to next slice */
1379 src += store.TotalBytesPerRow * (store.TotalRowsPerSlice - store.CopyRowsPerSlice);
1380 }
1381 else {
1382 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage%uD",
1383 dims);
1384 }
1385 }
1386
1387 _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
1388 }