projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'master' into i915-unification
[mesa.git] / src / mesa / drivers / dri / r300 / r300_tex.c
1 /*
2 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
3
4 The Weather Channel (TM) funded Tungsten Graphics to develop the
5 initial release of the Radeon 8500 driver under the XFree86 license.
6 This notice must be preserved.
7
8 Permission is hereby granted, free of charge, to any person obtaining
9 a copy of this software and associated documentation files (the
10 "Software"), to deal in the Software without restriction, including
11 without limitation the rights to use, copy, modify, merge, publish,
12 distribute, sublicense, and/or sell copies of the Software, and to
13 permit persons to whom the Software is furnished to do so, subject to
14 the following conditions:
15
16 The above copyright notice and this permission notice (including the
17 next paragraph) shall be included in all copies or substantial
18 portions of the Software.
19
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 */
28
29 /**
30 * \file
31 *
32 * \author Keith Whitwell <keith@tungstengraphics.com>
33 */
34
35 #include "glheader.h"
36 #include "imports.h"
37 #include "colormac.h"
38 #include "context.h"
39 #include "enums.h"
40 #include "image.h"
41 #include "simple_list.h"
42 #include "texformat.h"
43 #include "texstore.h"
44 #include "texmem.h"
45 #include "teximage.h"
46 #include "texobj.h"
47
48 #include "r300_context.h"
49 #include "r300_state.h"
50 #include "r300_ioctl.h"
51 #include "r300_tex.h"
52
53 #include "xmlpool.h"
54
55 /**
56 * Set the texture wrap modes.
57 *
58 * \param t Texture object whose wrap modes are to be set
59 * \param swrap Wrap mode for the \a s texture coordinate
60 * \param twrap Wrap mode for the \a t texture coordinate
61 */
62
63 static void r300SetTexWrap(r300TexObjPtr t, GLenum swrap, GLenum twrap,
64 GLenum rwrap)
65 {
66 unsigned long hw_swrap = 0, hw_twrap = 0, hw_qwrap = 0;
67
68 t->filter &=
69 ~(R300_TX_WRAP_S_MASK | R300_TX_WRAP_T_MASK | R300_TX_WRAP_Q_MASK);
70
71 switch (swrap) {
72 case GL_REPEAT:
73 hw_swrap |= R300_TX_REPEAT;
74 break;
75 case GL_CLAMP:
76 hw_swrap |= R300_TX_CLAMP;
77 break;
78 case GL_CLAMP_TO_EDGE:
79 hw_swrap |= R300_TX_CLAMP_TO_EDGE;
80 break;
81 case GL_CLAMP_TO_BORDER:
82 hw_swrap |= R300_TX_CLAMP_TO_BORDER;
83 break;
84 case GL_MIRRORED_REPEAT:
85 hw_swrap |= R300_TX_REPEAT | R300_TX_MIRRORED;
86 break;
87 case GL_MIRROR_CLAMP_EXT:
88 hw_swrap |= R300_TX_CLAMP | R300_TX_MIRRORED;
89 break;
90 case GL_MIRROR_CLAMP_TO_EDGE_EXT:
91 hw_swrap |= R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
92 break;
93 case GL_MIRROR_CLAMP_TO_BORDER_EXT:
94 hw_swrap |= R300_TX_CLAMP_TO_BORDER | R300_TX_MIRRORED;
95 break;
96 default:
97 _mesa_problem(NULL, "bad S wrap mode in %s", __FUNCTION__);
98 }
99
100 switch (twrap) {
101 case GL_REPEAT:
102 hw_twrap |= R300_TX_REPEAT;
103 break;
104 case GL_CLAMP:
105 hw_twrap |= R300_TX_CLAMP;
106 break;
107 case GL_CLAMP_TO_EDGE:
108 hw_twrap |= R300_TX_CLAMP_TO_EDGE;
109 break;
110 case GL_CLAMP_TO_BORDER:
111 hw_twrap |= R300_TX_CLAMP_TO_BORDER;
112 break;
113 case GL_MIRRORED_REPEAT:
114 hw_twrap |= R300_TX_REPEAT | R300_TX_MIRRORED;
115 break;
116 case GL_MIRROR_CLAMP_EXT:
117 hw_twrap |= R300_TX_CLAMP | R300_TX_MIRRORED;
118 break;
119 case GL_MIRROR_CLAMP_TO_EDGE_EXT:
120 hw_twrap |= R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
121 break;
122 case GL_MIRROR_CLAMP_TO_BORDER_EXT:
123 hw_twrap |= R300_TX_CLAMP_TO_BORDER | R300_TX_MIRRORED;
124 break;
125 default:
126 _mesa_problem(NULL, "bad T wrap mode in %s", __FUNCTION__);
127 }
128
129 switch (rwrap) {
130 case GL_REPEAT:
131 hw_qwrap |= R300_TX_REPEAT;
132 break;
133 case GL_CLAMP:
134 hw_qwrap |= R300_TX_CLAMP;
135 break;
136 case GL_CLAMP_TO_EDGE:
137 hw_qwrap |= R300_TX_CLAMP_TO_EDGE;
138 break;
139 case GL_CLAMP_TO_BORDER:
140 hw_qwrap |= R300_TX_CLAMP_TO_BORDER;
141 break;
142 case GL_MIRRORED_REPEAT:
143 hw_qwrap |= R300_TX_REPEAT | R300_TX_MIRRORED;
144 break;
145 case GL_MIRROR_CLAMP_EXT:
146 hw_qwrap |= R300_TX_CLAMP | R300_TX_MIRRORED;
147 break;
148 case GL_MIRROR_CLAMP_TO_EDGE_EXT:
149 hw_qwrap |= R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
150 break;
151 case GL_MIRROR_CLAMP_TO_BORDER_EXT:
152 hw_qwrap |= R300_TX_CLAMP_TO_BORDER | R300_TX_MIRRORED;
153 break;
154 default:
155 _mesa_problem(NULL, "bad R wrap mode in %s", __FUNCTION__);
156 }
157
158 t->filter |= hw_swrap << R300_TX_WRAP_S_SHIFT;
159 t->filter |= hw_twrap << R300_TX_WRAP_T_SHIFT;
160 t->filter |= hw_qwrap << R300_TX_WRAP_Q_SHIFT;
161 }
162
163 static void r300SetTexMaxAnisotropy(r300TexObjPtr t, GLfloat max)
164 {
165
166 t->filter &= ~R300_TX_MAX_ANISO_MASK;
167
168 if (max <= 1.0) {
169 t->filter |= R300_TX_MAX_ANISO_1_TO_1;
170 } else if (max <= 2.0) {
171 t->filter |= R300_TX_MAX_ANISO_2_TO_1;
172 } else if (max <= 4.0) {
173 t->filter |= R300_TX_MAX_ANISO_4_TO_1;
174 } else if (max <= 8.0) {
175 t->filter |= R300_TX_MAX_ANISO_8_TO_1;
176 } else {
177 t->filter |= R300_TX_MAX_ANISO_16_TO_1;
178 }
179 }
180
181 /**
182 * Set the texture magnification and minification modes.
183 *
184 * \param t Texture whose filter modes are to be set
185 * \param minf Texture minification mode
186 * \param magf Texture magnification mode
187 */
188
189 static void r300SetTexFilter(r300TexObjPtr t, GLenum minf, GLenum magf)
190 {
191 GLuint anisotropy = (t->filter & R300_TX_MAX_ANISO_MASK);
192
193 t->filter &= ~(R300_TX_MIN_FILTER_MASK | R300_TX_MAG_FILTER_MASK);
194
195 if (anisotropy == R300_TX_MAX_ANISO_1_TO_1) {
196 switch (minf) {
197 case GL_NEAREST:
198 t->filter |= R300_TX_MIN_FILTER_NEAREST;
199 break;
200 case GL_LINEAR:
201 t->filter |= R300_TX_MIN_FILTER_LINEAR;
202 break;
203 case GL_NEAREST_MIPMAP_NEAREST:
204 t->filter |= R300_TX_MIN_FILTER_NEAREST_MIP_NEAREST;
205 break;
206 case GL_NEAREST_MIPMAP_LINEAR:
207 t->filter |= R300_TX_MIN_FILTER_NEAREST_MIP_LINEAR;
208 break;
209 case GL_LINEAR_MIPMAP_NEAREST:
210 t->filter |= R300_TX_MIN_FILTER_LINEAR_MIP_NEAREST;
211 break;
212 case GL_LINEAR_MIPMAP_LINEAR:
213 t->filter |= R300_TX_MIN_FILTER_LINEAR_MIP_LINEAR;
214 break;
215 }
216 } else {
217 switch (minf) {
218 case GL_NEAREST:
219 t->filter |= R300_TX_MIN_FILTER_ANISO_NEAREST;
220 break;
221 case GL_LINEAR:
222 t->filter |= R300_TX_MIN_FILTER_ANISO_LINEAR;
223 break;
224 case GL_NEAREST_MIPMAP_NEAREST:
225 case GL_LINEAR_MIPMAP_NEAREST:
226 t->filter |=
227 R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_NEAREST;
228 break;
229 case GL_NEAREST_MIPMAP_LINEAR:
230 case GL_LINEAR_MIPMAP_LINEAR:
231 t->filter |=
232 R300_TX_MIN_FILTER_ANISO_NEAREST_MIP_LINEAR;
233 break;
234 }
235 }
236
237 /* Note we don't have 3D mipmaps so only use the mag filter setting
238 * to set the 3D texture filter mode.
239 */
240 switch (magf) {
241 case GL_NEAREST:
242 t->filter |= R300_TX_MAG_FILTER_NEAREST;
243 break;
244 case GL_LINEAR:
245 t->filter |= R300_TX_MAG_FILTER_LINEAR;
246 break;
247 }
248 }
249
250 static void r300SetTexBorderColor(r300TexObjPtr t, GLubyte c[4])
251 {
252 t->pp_border_color = PACK_COLOR_8888(c[0], c[1], c[2], c[3]);
253 }
254
255 /**
256 * Allocate space for and load the mesa images into the texture memory block.
257 * This will happen before drawing with a new texture, or drawing with a
258 * texture after it was swapped out or teximaged again.
259 */
260
261 static r300TexObjPtr r300AllocTexObj(struct gl_texture_object *texObj)
262 {
263 r300TexObjPtr t;
264
265 t = CALLOC_STRUCT(r300_tex_obj);
266 texObj->DriverData = t;
267 if (t != NULL) {
268 if (RADEON_DEBUG & DEBUG_TEXTURE) {
269 fprintf(stderr, "%s( %p, %p )\n", __FUNCTION__,
270 (void *)texObj, (void *)t);
271 }
272
273 /* Initialize non-image-dependent parts of the state:
274 */
275 t->base.tObj = texObj;
276 t->border_fallback = GL_FALSE;
277
278 make_empty_list(&t->base);
279
280 r300SetTexWrap(t, texObj->WrapS, texObj->WrapT, texObj->WrapR);
281 r300SetTexMaxAnisotropy(t, texObj->MaxAnisotropy);
282 r300SetTexFilter(t, texObj->MinFilter, texObj->MagFilter);
283 r300SetTexBorderColor(t, texObj->_BorderChan);
284 }
285
286 return t;
287 }
288
289 /* try to find a format which will only need a memcopy */
290 static const struct gl_texture_format *r300Choose8888TexFormat(GLenum srcFormat,
291 GLenum srcType)
292 {
293 const GLuint ui = 1;
294 const GLubyte littleEndian = *((const GLubyte *)&ui);
295
296 if ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
297 (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE
298 && !littleEndian) || (srcFormat == GL_ABGR_EXT
299 && srcType == GL_UNSIGNED_INT_8_8_8_8_REV)
300 || (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE
301 && littleEndian)) {
302 return &_mesa_texformat_rgba8888;
303 } else
304 if ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV)
305 || (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE
306 && littleEndian) || (srcFormat == GL_ABGR_EXT
307 && srcType == GL_UNSIGNED_INT_8_8_8_8)
308 || (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE
309 && !littleEndian)) {
310 return &_mesa_texformat_rgba8888_rev;
311 } else if (srcFormat == GL_BGRA &&
312 ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
313 srcType == GL_UNSIGNED_INT_8_8_8_8)) {
314 return &_mesa_texformat_argb8888_rev;
315 } else if (srcFormat == GL_BGRA &&
316 ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||
317 srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {
318 return &_mesa_texformat_argb8888;
319 } else
320 return _dri_texformat_argb8888;
321 }
322
323 static const struct gl_texture_format *r300ChooseTextureFormat(GLcontext * ctx,
324 GLint
325 internalFormat,
326 GLenum format,
327 GLenum type)
328 {
329 r300ContextPtr rmesa = R300_CONTEXT(ctx);
330 const GLboolean do32bpt =
331 (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_32);
332 const GLboolean force16bpt =
333 (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FORCE_16);
334 (void)format;
335
336 #if 0
337 fprintf(stderr, "InternalFormat=%s(%d) type=%s format=%s\n",
338 _mesa_lookup_enum_by_nr(internalFormat), internalFormat,
339 _mesa_lookup_enum_by_nr(type), _mesa_lookup_enum_by_nr(format));
340 fprintf(stderr, "do32bpt=%d force16bpt=%d\n", do32bpt, force16bpt);
341 #endif
342
343 switch (internalFormat) {
344 case 4:
345 case GL_RGBA:
346 case GL_COMPRESSED_RGBA:
347 switch (type) {
348 case GL_UNSIGNED_INT_10_10_10_2:
349 case GL_UNSIGNED_INT_2_10_10_10_REV:
350 return do32bpt ? _dri_texformat_argb8888 :
351 _dri_texformat_argb1555;
352 case GL_UNSIGNED_SHORT_4_4_4_4:
353 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
354 return _dri_texformat_argb4444;
355 case GL_UNSIGNED_SHORT_5_5_5_1:
356 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
357 return _dri_texformat_argb1555;
358 default:
359 return do32bpt ? r300Choose8888TexFormat(format, type) :
360 _dri_texformat_argb4444;
361 }
362
363 case 3:
364 case GL_RGB:
365 case GL_COMPRESSED_RGB:
366 switch (type) {
367 case GL_UNSIGNED_SHORT_4_4_4_4:
368 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
369 return _dri_texformat_argb4444;
370 case GL_UNSIGNED_SHORT_5_5_5_1:
371 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
372 return _dri_texformat_argb1555;
373 case GL_UNSIGNED_SHORT_5_6_5:
374 case GL_UNSIGNED_SHORT_5_6_5_REV:
375 return _dri_texformat_rgb565;
376 default:
377 return do32bpt ? _dri_texformat_argb8888 :
378 _dri_texformat_rgb565;
379 }
380
381 case GL_RGBA8:
382 case GL_RGB10_A2:
383 case GL_RGBA12:
384 case GL_RGBA16:
385 return !force16bpt ?
386 r300Choose8888TexFormat(format,
387 type) : _dri_texformat_argb4444;
388
389 case GL_RGBA4:
390 case GL_RGBA2:
391 return _dri_texformat_argb4444;
392
393 case GL_RGB5_A1:
394 return _dri_texformat_argb1555;
395
396 case GL_RGB8:
397 case GL_RGB10:
398 case GL_RGB12:
399 case GL_RGB16:
400 return !force16bpt ? _dri_texformat_argb8888 :
401 _dri_texformat_rgb565;
402
403 case GL_RGB5:
404 case GL_RGB4:
405 case GL_R3_G3_B2:
406 return _dri_texformat_rgb565;
407
408 case GL_ALPHA:
409 case GL_ALPHA4:
410 case GL_ALPHA8:
411 case GL_ALPHA12:
412 case GL_ALPHA16:
413 case GL_COMPRESSED_ALPHA:
414 return _dri_texformat_a8;
415
416 case 1:
417 case GL_LUMINANCE:
418 case GL_LUMINANCE4:
419 case GL_LUMINANCE8:
420 case GL_LUMINANCE12:
421 case GL_LUMINANCE16:
422 case GL_COMPRESSED_LUMINANCE:
423 return _dri_texformat_l8;
424
425 case 2:
426 case GL_LUMINANCE_ALPHA:
427 case GL_LUMINANCE4_ALPHA4:
428 case GL_LUMINANCE6_ALPHA2:
429 case GL_LUMINANCE8_ALPHA8:
430 case GL_LUMINANCE12_ALPHA4:
431 case GL_LUMINANCE12_ALPHA12:
432 case GL_LUMINANCE16_ALPHA16:
433 case GL_COMPRESSED_LUMINANCE_ALPHA:
434 return _dri_texformat_al88;
435
436 case GL_INTENSITY:
437 case GL_INTENSITY4:
438 case GL_INTENSITY8:
439 case GL_INTENSITY12:
440 case GL_INTENSITY16:
441 case GL_COMPRESSED_INTENSITY:
442 return _dri_texformat_i8;
443
444 case GL_YCBCR_MESA:
445 if (type == GL_UNSIGNED_SHORT_8_8_APPLE ||
446 type == GL_UNSIGNED_BYTE)
447 return &_mesa_texformat_ycbcr;
448 else
449 return &_mesa_texformat_ycbcr_rev;
450
451 case GL_RGB_S3TC:
452 case GL_RGB4_S3TC:
453 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
454 return &_mesa_texformat_rgb_dxt1;
455
456 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
457 return &_mesa_texformat_rgba_dxt1;
458
459 case GL_RGBA_S3TC:
460 case GL_RGBA4_S3TC:
461 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
462 return &_mesa_texformat_rgba_dxt3;
463
464 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
465 return &_mesa_texformat_rgba_dxt5;
466
467 case GL_ALPHA16F_ARB:
468 return &_mesa_texformat_alpha_float16;
469 case GL_ALPHA32F_ARB:
470 return &_mesa_texformat_alpha_float32;
471 case GL_LUMINANCE16F_ARB:
472 return &_mesa_texformat_luminance_float16;
473 case GL_LUMINANCE32F_ARB:
474 return &_mesa_texformat_luminance_float32;
475 case GL_LUMINANCE_ALPHA16F_ARB:
476 return &_mesa_texformat_luminance_alpha_float16;
477 case GL_LUMINANCE_ALPHA32F_ARB:
478 return &_mesa_texformat_luminance_alpha_float32;
479 case GL_INTENSITY16F_ARB:
480 return &_mesa_texformat_intensity_float16;
481 case GL_INTENSITY32F_ARB:
482 return &_mesa_texformat_intensity_float32;
483 case GL_RGB16F_ARB:
484 return &_mesa_texformat_rgba_float16;
485 case GL_RGB32F_ARB:
486 return &_mesa_texformat_rgba_float32;
487 case GL_RGBA16F_ARB:
488 return &_mesa_texformat_rgba_float16;
489 case GL_RGBA32F_ARB:
490 return &_mesa_texformat_rgba_float32;
491
492 default:
493 _mesa_problem(ctx,
494 "unexpected internalFormat 0x%x in r300ChooseTextureFormat",
495 (int)internalFormat);
496 return NULL;
497 }
498
499 return NULL; /* never get here */
500 }
501
502 static GLboolean
503 r300ValidateClientStorage(GLcontext * ctx, GLenum target,
504 GLint internalFormat,
505 GLint srcWidth, GLint srcHeight,
506 GLenum format, GLenum type, const void *pixels,
507 const struct gl_pixelstore_attrib *packing,
508 struct gl_texture_object *texObj,
509 struct gl_texture_image *texImage)
510 {
511 r300ContextPtr rmesa = R300_CONTEXT(ctx);
512
513 if (RADEON_DEBUG & DEBUG_TEXTURE)
514 fprintf(stderr, "intformat %s format %s type %s\n",
515 _mesa_lookup_enum_by_nr(internalFormat),
516 _mesa_lookup_enum_by_nr(format),
517 _mesa_lookup_enum_by_nr(type));
518
519 if (!ctx->Unpack.ClientStorage)
520 return 0;
521
522 if (ctx->_ImageTransferState ||
523 texImage->IsCompressed || texObj->GenerateMipmap)
524 return 0;
525
526 /* This list is incomplete, may be different on ppc???
527 */
528 switch (internalFormat) {
529 case GL_RGBA:
530 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV) {
531 texImage->TexFormat = _dri_texformat_argb8888;
532 } else
533 return 0;
534 break;
535
536 case GL_RGB:
537 if (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) {
538 texImage->TexFormat = _dri_texformat_rgb565;
539 } else
540 return 0;
541 break;
542
543 case GL_YCBCR_MESA:
544 if (format == GL_YCBCR_MESA &&
545 type == GL_UNSIGNED_SHORT_8_8_REV_APPLE) {
546 texImage->TexFormat = &_mesa_texformat_ycbcr_rev;
547 } else if (format == GL_YCBCR_MESA &&
548 (type == GL_UNSIGNED_SHORT_8_8_APPLE ||
549 type == GL_UNSIGNED_BYTE)) {
550 texImage->TexFormat = &_mesa_texformat_ycbcr;
551 } else
552 return 0;
553 break;
554
555 default:
556 return 0;
557 }
558
559 /* Could deal with these packing issues, but currently don't:
560 */
561 if (packing->SkipPixels ||
562 packing->SkipRows || packing->SwapBytes || packing->LsbFirst) {
563 return 0;
564 }
565
566 {
567 GLint srcRowStride = _mesa_image_row_stride(packing, srcWidth,
568 format, type);
569
570 if (RADEON_DEBUG & DEBUG_TEXTURE)
571 fprintf(stderr, "%s: srcRowStride %d/%x\n",
572 __FUNCTION__, srcRowStride, srcRowStride);
573
574 /* Could check this later in upload, pitch restrictions could be
575 * relaxed, but would need to store the image pitch somewhere,
576 * as packing details might change before image is uploaded:
577 */
578 if (!r300IsGartMemory(rmesa, pixels, srcHeight * srcRowStride)
579 || (srcRowStride & 63))
580 return 0;
581
582 /* Have validated that _mesa_transfer_teximage would be a straight
583 * memcpy at this point. NOTE: future calls to TexSubImage will
584 * overwrite the client data. This is explicitly mentioned in the
585 * extension spec.
586 */
587 texImage->Data = (void *)pixels;
588 texImage->IsClientData = GL_TRUE;
589 texImage->RowStride =
590 srcRowStride / texImage->TexFormat->TexelBytes;
591
592 return 1;
593 }
594 }
595
596 static void r300TexImage1D(GLcontext * ctx, GLenum target, GLint level,
597 GLint internalFormat,
598 GLint width, GLint border,
599 GLenum format, GLenum type, const GLvoid * pixels,
600 const struct gl_pixelstore_attrib *packing,
601 struct gl_texture_object *texObj,
602 struct gl_texture_image *texImage)
603 {
604 driTextureObject *t = (driTextureObject *) texObj->DriverData;
605
606 if (t) {
607 driSwapOutTextureObject(t);
608 } else {
609 t = (driTextureObject *) r300AllocTexObj(texObj);
610 if (!t) {
611 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
612 return;
613 }
614 }
615
616 /* Note, this will call ChooseTextureFormat */
617 _mesa_store_teximage1d(ctx, target, level, internalFormat,
618 width, border, format, type, pixels,
619 &ctx->Unpack, texObj, texImage);
620
621 t->dirty_images[0] |= (1 << level);
622 }
623
624 static void r300TexSubImage1D(GLcontext * ctx, GLenum target, GLint level,
625 GLint xoffset,
626 GLsizei width,
627 GLenum format, GLenum type,
628 const GLvoid * pixels,
629 const struct gl_pixelstore_attrib *packing,
630 struct gl_texture_object *texObj,
631 struct gl_texture_image *texImage)
632 {
633 driTextureObject *t = (driTextureObject *) texObj->DriverData;
634
635 assert(t); /* this _should_ be true */
636 if (t) {
637 driSwapOutTextureObject(t);
638 } else {
639 t = (driTextureObject *) r300AllocTexObj(texObj);
640 if (!t) {
641 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");
642 return;
643 }
644 }
645
646 _mesa_store_texsubimage1d(ctx, target, level, xoffset, width,
647 format, type, pixels, packing, texObj,
648 texImage);
649
650 t->dirty_images[0] |= (1 << level);
651 }
652
653 static void r300TexImage2D(GLcontext * ctx, GLenum target, GLint level,
654 GLint internalFormat,
655 GLint width, GLint height, GLint border,
656 GLenum format, GLenum type, const GLvoid * pixels,
657 const struct gl_pixelstore_attrib *packing,
658 struct gl_texture_object *texObj,
659 struct gl_texture_image *texImage)
660 {
661 driTextureObject *t = (driTextureObject *) texObj->DriverData;
662 GLuint face;
663
664 /* which cube face or ordinary 2D image */
665 switch (target) {
666 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
667 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
668 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
669 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
670 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
671 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
672 face =
673 (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
674 ASSERT(face < 6);
675 break;
676 default:
677 face = 0;
678 }
679
680 if (t != NULL) {
681 driSwapOutTextureObject(t);
682 } else {
683 t = (driTextureObject *) r300AllocTexObj(texObj);
684 if (!t) {
685 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
686 return;
687 }
688 }
689
690 texImage->IsClientData = GL_FALSE;
691
692 if (r300ValidateClientStorage(ctx, target,
693 internalFormat,
694 width, height,
695 format, type, pixels,
696 packing, texObj, texImage)) {
697 if (RADEON_DEBUG & DEBUG_TEXTURE)
698 fprintf(stderr, "%s: Using client storage\n",
699 __FUNCTION__);
700 } else {
701 if (RADEON_DEBUG & DEBUG_TEXTURE)
702 fprintf(stderr, "%s: Using normal storage\n",
703 __FUNCTION__);
704
705 /* Normal path: copy (to cached memory) and eventually upload
706 * via another copy to GART memory and then a blit... Could
707 * eliminate one copy by going straight to (permanent) GART.
708 *
709 * Note, this will call r300ChooseTextureFormat.
710 */
711 _mesa_store_teximage2d(ctx, target, level, internalFormat,
712 width, height, border, format, type,
713 pixels, &ctx->Unpack, texObj, texImage);
714
715 t->dirty_images[face] |= (1 << level);
716 }
717 }
718
719 static void r300TexSubImage2D(GLcontext * ctx, GLenum target, GLint level,
720 GLint xoffset, GLint yoffset,
721 GLsizei width, GLsizei height,
722 GLenum format, GLenum type,
723 const GLvoid * pixels,
724 const struct gl_pixelstore_attrib *packing,
725 struct gl_texture_object *texObj,
726 struct gl_texture_image *texImage)
727 {
728 driTextureObject *t = (driTextureObject *) texObj->DriverData;
729 GLuint face;
730
731 /* which cube face or ordinary 2D image */
732 switch (target) {
733 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
734 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
735 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
736 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
737 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
738 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
739 face =
740 (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
741 ASSERT(face < 6);
742 break;
743 default:
744 face = 0;
745 }
746
747 assert(t); /* this _should_ be true */
748 if (t) {
749 driSwapOutTextureObject(t);
750 } else {
751 t = (driTextureObject *) r300AllocTexObj(texObj);
752 if (!t) {
753 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");
754 return;
755 }
756 }
757
758 _mesa_store_texsubimage2d(ctx, target, level, xoffset, yoffset, width,
759 height, format, type, pixels, packing, texObj,
760 texImage);
761
762 t->dirty_images[face] |= (1 << level);
763 }
764
765 static void r300CompressedTexImage2D(GLcontext * ctx, GLenum target,
766 GLint level, GLint internalFormat,
767 GLint width, GLint height, GLint border,
768 GLsizei imageSize, const GLvoid * data,
769 struct gl_texture_object *texObj,
770 struct gl_texture_image *texImage)
771 {
772 driTextureObject *t = (driTextureObject *) texObj->DriverData;
773 GLuint face;
774
775 /* which cube face or ordinary 2D image */
776 switch (target) {
777 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
778 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
779 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
780 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
781 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
782 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
783 face =
784 (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
785 ASSERT(face < 6);
786 break;
787 default:
788 face = 0;
789 }
790
791 if (t != NULL) {
792 driSwapOutTextureObject(t);
793 } else {
794 t = (driTextureObject *) r300AllocTexObj(texObj);
795 if (!t) {
796 _mesa_error(ctx, GL_OUT_OF_MEMORY,
797 "glCompressedTexImage2D");
798 return;
799 }
800 }
801
802 texImage->IsClientData = GL_FALSE;
803
804 /* can't call this, different parameters. Would never evaluate to true anyway currently */
805 #if 0
806 if (r300ValidateClientStorage(ctx, target,
807 internalFormat,
808 width, height,
809 format, type, pixels,
810 packing, texObj, texImage)) {
811 if (RADEON_DEBUG & DEBUG_TEXTURE)
812 fprintf(stderr, "%s: Using client storage\n",
813 __FUNCTION__);
814 } else
815 #endif
816 {
817 if (RADEON_DEBUG & DEBUG_TEXTURE)
818 fprintf(stderr, "%s: Using normal storage\n",
819 __FUNCTION__);
820
821 /* Normal path: copy (to cached memory) and eventually upload
822 * via another copy to GART memory and then a blit... Could
823 * eliminate one copy by going straight to (permanent) GART.
824 *
825 * Note, this will call r300ChooseTextureFormat.
826 */
827 _mesa_store_compressed_teximage2d(ctx, target, level,
828 internalFormat, width, height,
829 border, imageSize, data,
830 texObj, texImage);
831
832 t->dirty_images[face] |= (1 << level);
833 }
834 }
835
836 static void r300CompressedTexSubImage2D(GLcontext * ctx, GLenum target,
837 GLint level, GLint xoffset,
838 GLint yoffset, GLsizei width,
839 GLsizei height, GLenum format,
840 GLsizei imageSize, const GLvoid * data,
841 struct gl_texture_object *texObj,
842 struct gl_texture_image *texImage)
843 {
844 driTextureObject *t = (driTextureObject *) texObj->DriverData;
845 GLuint face;
846
847 /* which cube face or ordinary 2D image */
848 switch (target) {
849 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
850 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
851 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
852 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
853 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
854 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
855 face =
856 (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
857 ASSERT(face < 6);
858 break;
859 default:
860 face = 0;
861 }
862
863 assert(t); /* this _should_ be true */
864 if (t) {
865 driSwapOutTextureObject(t);
866 } else {
867 t = (driTextureObject *) r300AllocTexObj(texObj);
868 if (!t) {
869 _mesa_error(ctx, GL_OUT_OF_MEMORY,
870 "glCompressedTexSubImage3D");
871 return;
872 }
873 }
874
875 _mesa_store_compressed_texsubimage2d(ctx, target, level, xoffset,
876 yoffset, width, height, format,
877 imageSize, data, texObj, texImage);
878
879 t->dirty_images[face] |= (1 << level);
880 }
881
882 static void r300TexImage3D(GLcontext * ctx, GLenum target, GLint level,
883 GLint internalFormat,
884 GLint width, GLint height, GLint depth,
885 GLint border,
886 GLenum format, GLenum type, const GLvoid * pixels,
887 const struct gl_pixelstore_attrib *packing,
888 struct gl_texture_object *texObj,
889 struct gl_texture_image *texImage)
890 {
891 driTextureObject *t = (driTextureObject *) texObj->DriverData;
892
893 if (t) {
894 driSwapOutTextureObject(t);
895 } else {
896 t = (driTextureObject *) r300AllocTexObj(texObj);
897 if (!t) {
898 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
899 return;
900 }
901 }
902
903 texImage->IsClientData = GL_FALSE;
904
905 #if 0
906 if (r300ValidateClientStorage(ctx, target,
907 internalFormat,
908 width, height,
909 format, type, pixels,
910 packing, texObj, texImage)) {
911 if (RADEON_DEBUG & DEBUG_TEXTURE)
912 fprintf(stderr, "%s: Using client storage\n",
913 __FUNCTION__);
914 } else
915 #endif
916 {
917 if (RADEON_DEBUG & DEBUG_TEXTURE)
918 fprintf(stderr, "%s: Using normal storage\n",
919 __FUNCTION__);
920
921 /* Normal path: copy (to cached memory) and eventually upload
922 * via another copy to GART memory and then a blit... Could
923 * eliminate one copy by going straight to (permanent) GART.
924 *
925 * Note, this will call r300ChooseTextureFormat.
926 */
927 _mesa_store_teximage3d(ctx, target, level, internalFormat,
928 width, height, depth, border,
929 format, type, pixels,
930 &ctx->Unpack, texObj, texImage);
931
932 t->dirty_images[0] |= (1 << level);
933 }
934 }
935
936 static void
937 r300TexSubImage3D(GLcontext * ctx, GLenum target, GLint level,
938 GLint xoffset, GLint yoffset, GLint zoffset,
939 GLsizei width, GLsizei height, GLsizei depth,
940 GLenum format, GLenum type,
941 const GLvoid * pixels,
942 const struct gl_pixelstore_attrib *packing,
943 struct gl_texture_object *texObj,
944 struct gl_texture_image *texImage)
945 {
946 driTextureObject *t = (driTextureObject *) texObj->DriverData;
947
948 /* fprintf(stderr, "%s\n", __FUNCTION__); */
949
950 assert(t); /* this _should_ be true */
951 if (t) {
952 driSwapOutTextureObject(t);
953 } else {
954 t = (driTextureObject *) r300AllocTexObj(texObj);
955 if (!t) {
956 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");
957 return;
958 }
959 texObj->DriverData = t;
960 }
961
962 _mesa_store_texsubimage3d(ctx, target, level, xoffset, yoffset, zoffset,
963 width, height, depth,
964 format, type, pixels, packing, texObj,
965 texImage);
966
967 t->dirty_images[0] |= (1 << level);
968 }
969
970 static void r300TexEnv(GLcontext * ctx, GLenum target,
971 GLenum pname, const GLfloat * param)
972 {
973 if (RADEON_DEBUG & DEBUG_STATE) {
974 fprintf(stderr, "%s( %s )\n",
975 __FUNCTION__, _mesa_lookup_enum_by_nr(pname));
976 }
977
978 /* This is incorrect: Need to maintain this data for each of
979 * GL_TEXTURE_{123}D, GL_TEXTURE_RECTANGLE_NV, etc, and switch
980 * between them according to _ReallyEnabled.
981 */
982 switch (pname) {
983 case GL_TEXTURE_LOD_BIAS_EXT:{
984 #if 0 /* Needs to be relocated in order to make sure we got the right tmu */
985 GLfloat bias, min;
986 GLuint b;
987
988 /* The R300's LOD bias is a signed 2's complement value with a
989 * range of -16.0 <= bias < 16.0.
990 *
991 * NOTE: Add a small bias to the bias for conform mipsel.c test.
992 */
993 bias = *param + .01;
994 min =
995 driQueryOptionb(&rmesa->radeon.optionCache,
996 "no_neg_lod_bias") ? 0.0 : -16.0;
997 bias = CLAMP(bias, min, 16.0);
998
999 /* 0.0 - 16.0 == 0x0 - 0x1000 */
1000 /* 0.0 - -16.0 == 0x1001 - 0x1fff */
1001 b = 0x1000 / 16.0 * bias;
1002 b &= R300_LOD_BIAS_MASK;
1003
1004 if (b !=
1005 (rmesa->hw.tex.unknown1.
1006 cmd[R300_TEX_VALUE_0 +
1007 unit] & R300_LOD_BIAS_MASK)) {
1008 R300_STATECHANGE(rmesa, tex.unknown1);
1009 rmesa->hw.tex.unknown1.cmd[R300_TEX_VALUE_0 +
1010 unit] &=
1011 ~R300_LOD_BIAS_MASK;
1012 rmesa->hw.tex.unknown1.cmd[R300_TEX_VALUE_0 +
1013 unit] |= b;
1014 }
1015 #endif
1016 break;
1017 }
1018
1019 default:
1020 return;
1021 }
1022 }
1023
1024 /**
1025 * Changes variables and flags for a state update, which will happen at the
1026 * next UpdateTextureState
1027 */
1028
1029 static void r300TexParameter(GLcontext * ctx, GLenum target,
1030 struct gl_texture_object *texObj,
1031 GLenum pname, const GLfloat * params)
1032 {
1033 r300TexObjPtr t = (r300TexObjPtr) texObj->DriverData;
1034
1035 if (RADEON_DEBUG & (DEBUG_STATE | DEBUG_TEXTURE)) {
1036 fprintf(stderr, "%s( %s )\n", __FUNCTION__,
1037 _mesa_lookup_enum_by_nr(pname));
1038 }
1039
1040 switch (pname) {
1041 case GL_TEXTURE_MIN_FILTER:
1042 case GL_TEXTURE_MAG_FILTER:
1043 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1044 r300SetTexMaxAnisotropy(t, texObj->MaxAnisotropy);
1045 r300SetTexFilter(t, texObj->MinFilter, texObj->MagFilter);
1046 break;
1047
1048 case GL_TEXTURE_WRAP_S:
1049 case GL_TEXTURE_WRAP_T:
1050 case GL_TEXTURE_WRAP_R:
1051 r300SetTexWrap(t, texObj->WrapS, texObj->WrapT, texObj->WrapR);
1052 break;
1053
1054 case GL_TEXTURE_BORDER_COLOR:
1055 r300SetTexBorderColor(t, texObj->_BorderChan);
1056 break;
1057
1058 case GL_TEXTURE_BASE_LEVEL:
1059 case GL_TEXTURE_MAX_LEVEL:
1060 case GL_TEXTURE_MIN_LOD:
1061 case GL_TEXTURE_MAX_LOD:
1062 /* This isn't the most efficient solution but there doesn't appear to
1063 * be a nice alternative. Since there's no LOD clamping,
1064 * we just have to rely on loading the right subset of mipmap levels
1065 * to simulate a clamped LOD.
1066 */
1067 driSwapOutTextureObject((driTextureObject *) t);
1068 break;
1069
1070 default:
1071 return;
1072 }
1073
1074 /* Mark this texobj as dirty (one bit per tex unit)
1075 */
1076 t->dirty_state = TEX_ALL;
1077 }
1078
1079 static void r300BindTexture(GLcontext * ctx, GLenum target,
1080 struct gl_texture_object *texObj)
1081 {
1082 if (RADEON_DEBUG & (DEBUG_STATE | DEBUG_TEXTURE)) {
1083 fprintf(stderr, "%s( %p ) unit=%d\n", __FUNCTION__,
1084 (void *)texObj, ctx->Texture.CurrentUnit);
1085 }
1086
1087 if ((target == GL_TEXTURE_1D)
1088 || (target == GL_TEXTURE_2D)
1089 || (target == GL_TEXTURE_3D)
1090 || (target == GL_TEXTURE_CUBE_MAP)
1091 || (target == GL_TEXTURE_RECTANGLE_NV)) {
1092 assert(texObj->DriverData != NULL);
1093 }
1094 }
1095
1096 static void r300DeleteTexture(GLcontext * ctx, struct gl_texture_object *texObj)
1097 {
1098 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1099 driTextureObject *t = (driTextureObject *) texObj->DriverData;
1100
1101 if (RADEON_DEBUG & (DEBUG_STATE | DEBUG_TEXTURE)) {
1102 fprintf(stderr, "%s( %p (target = %s) )\n", __FUNCTION__,
1103 (void *)texObj,
1104 _mesa_lookup_enum_by_nr(texObj->Target));
1105 }
1106
1107 if (t != NULL) {
1108 if (rmesa) {
1109 R300_FIREVERTICES(rmesa);
1110 }
1111
1112 driDestroyTextureObject(t);
1113 }
1114 /* Free mipmap images and the texture object itself */
1115 _mesa_delete_texture_object(ctx, texObj);
1116 }
1117
1118 /**
1119 * Allocate a new texture object.
1120 * Called via ctx->Driver.NewTextureObject.
1121 * Note: this function will be called during context creation to
1122 * allocate the default texture objects.
1123 * Note: we could use containment here to 'derive' the driver-specific
1124 * texture object from the core mesa gl_texture_object. Not done at this time.
1125 * Fixup MaxAnisotropy according to user preference.
1126 */
1127 static struct gl_texture_object *r300NewTextureObject(GLcontext * ctx,
1128 GLuint name,
1129 GLenum target)
1130 {
1131 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1132 struct gl_texture_object *obj;
1133 obj = _mesa_new_texture_object(ctx, name, target);
1134 if (!obj)
1135 return NULL;
1136 obj->MaxAnisotropy = rmesa->initialMaxAnisotropy;
1137
1138 r300AllocTexObj(obj);
1139 return obj;
1140 }
1141
1142 void r300InitTextureFuncs(struct dd_function_table *functions)
1143 {
1144 /* Note: we only plug in the functions we implement in the driver
1145 * since _mesa_init_driver_functions() was already called.
1146 */
1147 functions->ChooseTextureFormat = r300ChooseTextureFormat;
1148 functions->TexImage1D = r300TexImage1D;
1149 functions->TexImage2D = r300TexImage2D;
1150 functions->TexImage3D = r300TexImage3D;
1151 functions->TexSubImage1D = r300TexSubImage1D;
1152 functions->TexSubImage2D = r300TexSubImage2D;
1153 functions->TexSubImage3D = r300TexSubImage3D;
1154 functions->NewTextureObject = r300NewTextureObject;
1155 functions->BindTexture = r300BindTexture;
1156 functions->DeleteTexture = r300DeleteTexture;
1157 functions->IsTextureResident = driIsTextureResident;
1158
1159 functions->TexEnv = r300TexEnv;
1160 functions->TexParameter = r300TexParameter;
1161
1162 functions->CompressedTexImage2D = r300CompressedTexImage2D;
1163 functions->CompressedTexSubImage2D = r300CompressedTexSubImage2D;
1164
1165 driInitTextureFormats();
1166 }