projects / mesa.git / blob
? search:


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