1/*
2 * Mesa 3-D graphics library
3 * Version:  6.5.3
4 *
5 * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
6 * Copyright (c) 2008 VMware, Inc.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27/**
28 * \file texcompress_s3tc.c
29 * GL_EXT_texture_compression_s3tc support.
30 */
31
32#ifndef USE_EXTERNAL_DXTN_LIB
33#define USE_EXTERNAL_DXTN_LIB 1
34#endif
35
36#include "glheader.h"
37#include "imports.h"
38#include "colormac.h"
39#include "dlopen.h"
40#include "image.h"
41#include "macros.h"
42#include "mfeatures.h"
43#include "mtypes.h"
44#include "texcompress.h"
45#include "texcompress_s3tc.h"
46#include "texstore.h"
47#include "swrast/s_context.h"
48
49
50#if FEATURE_texture_s3tc
51
52
53#if defined(_WIN32) || defined(WIN32)
54#define DXTN_LIBNAME "dxtn.dll"
55#define RTLD_LAZY 0
56#define RTLD_GLOBAL 0
57#elif defined(__DJGPP__)
58#define DXTN_LIBNAME "dxtn.dxe"
59#else
60#define DXTN_LIBNAME "libtxc_dxtn.so"
61#endif
62
63#if FEATURE_EXT_texture_sRGB
64/**
65 * Convert an 8-bit sRGB value from non-linear space to a
66 * linear RGB value in [0, 1].
67 * Implemented with a 256-entry lookup table.
68 */
69static inline GLfloat
70nonlinear_to_linear(GLubyte cs8)
71{
72   static GLfloat table[256];
73   static GLboolean tableReady = GL_FALSE;
74   if (!tableReady) {
75      /* compute lookup table now */
76      GLuint i;
77      for (i = 0; i < 256; i++) {
78         const GLfloat cs = UBYTE_TO_FLOAT(i);
79         if (cs <= 0.04045) {
80            table[i] = cs / 12.92f;
81         }
82         else {
83            table[i] = (GLfloat) pow((cs + 0.055) / 1.055, 2.4);
84         }
85      }
86      tableReady = GL_TRUE;
87   }
88   return table[cs8];
89}
90#endif /* FEATURE_EXT_texture_sRGB */
91
92typedef void (*dxtFetchTexelFuncExt)( GLint srcRowstride, GLubyte *pixdata, GLint col, GLint row, GLvoid *texelOut );
93
94dxtFetchTexelFuncExt fetch_ext_rgb_dxt1 = NULL;
95dxtFetchTexelFuncExt fetch_ext_rgba_dxt1 = NULL;
96dxtFetchTexelFuncExt fetch_ext_rgba_dxt3 = NULL;
97dxtFetchTexelFuncExt fetch_ext_rgba_dxt5 = NULL;
98
99typedef void (*dxtCompressTexFuncExt)(GLint srccomps, GLint width,
100                                      GLint height, const GLubyte *srcPixData,
101                                      GLenum destformat, GLubyte *dest,
102                                      GLint dstRowStride);
103
104static dxtCompressTexFuncExt ext_tx_compress_dxtn = NULL;
105
106static void *dxtlibhandle = NULL;
107
108
109void
110_mesa_init_texture_s3tc( struct gl_context *ctx )
111{
112   /* called during context initialization */
113   ctx->Mesa_DXTn = GL_FALSE;
114#if USE_EXTERNAL_DXTN_LIB
115   if (!dxtlibhandle) {
116      dxtlibhandle = _mesa_dlopen(DXTN_LIBNAME, 0);
117      if (!dxtlibhandle) {
118	 _mesa_warning(ctx, "couldn't open " DXTN_LIBNAME ", software DXTn "
119	    "compression/decompression unavailable");
120      }
121      else {
122         /* the fetch functions are not per context! Might be problematic... */
123         fetch_ext_rgb_dxt1 = (dxtFetchTexelFuncExt)
124            _mesa_dlsym(dxtlibhandle, "fetch_2d_texel_rgb_dxt1");
125         fetch_ext_rgba_dxt1 = (dxtFetchTexelFuncExt)
126            _mesa_dlsym(dxtlibhandle, "fetch_2d_texel_rgba_dxt1");
127         fetch_ext_rgba_dxt3 = (dxtFetchTexelFuncExt)
128            _mesa_dlsym(dxtlibhandle, "fetch_2d_texel_rgba_dxt3");
129         fetch_ext_rgba_dxt5 = (dxtFetchTexelFuncExt)
130            _mesa_dlsym(dxtlibhandle, "fetch_2d_texel_rgba_dxt5");
131         ext_tx_compress_dxtn = (dxtCompressTexFuncExt)
132            _mesa_dlsym(dxtlibhandle, "tx_compress_dxtn");
133
134         if (!fetch_ext_rgb_dxt1 ||
135             !fetch_ext_rgba_dxt1 ||
136             !fetch_ext_rgba_dxt3 ||
137             !fetch_ext_rgba_dxt5 ||
138             !ext_tx_compress_dxtn) {
139	    _mesa_warning(ctx, "couldn't reference all symbols in "
140	       DXTN_LIBNAME ", software DXTn compression/decompression "
141	       "unavailable");
142            fetch_ext_rgb_dxt1 = NULL;
143            fetch_ext_rgba_dxt1 = NULL;
144            fetch_ext_rgba_dxt3 = NULL;
145            fetch_ext_rgba_dxt5 = NULL;
146            ext_tx_compress_dxtn = NULL;
147            _mesa_dlclose(dxtlibhandle);
148            dxtlibhandle = NULL;
149         }
150      }
151   }
152   if (dxtlibhandle) {
153      ctx->Mesa_DXTn = GL_TRUE;
154   }
155#else
156   (void) ctx;
157#endif
158}
159
160/**
161 * Store user's image in rgb_dxt1 format.
162 */
163GLboolean
164_mesa_texstore_rgb_dxt1(TEXSTORE_PARAMS)
165{
166   const GLubyte *pixels;
167   GLubyte *dst;
168   const GLubyte *tempImage = NULL;
169
170   ASSERT(dstFormat == MESA_FORMAT_RGB_DXT1 ||
171          dstFormat == MESA_FORMAT_SRGB_DXT1);
172
173   if (srcFormat != GL_RGB ||
174       srcType != GL_UNSIGNED_BYTE ||
175       ctx->_ImageTransferState ||
176       srcPacking->RowLength != srcWidth ||
177       srcPacking->SwapBytes) {
178      /* convert image to RGB/GLubyte */
179      tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
180                                             baseInternalFormat,
181                                             _mesa_get_format_base_format(dstFormat),
182                                             srcWidth, srcHeight, srcDepth,
183                                             srcFormat, srcType, srcAddr,
184                                             srcPacking);
185      if (!tempImage)
186         return GL_FALSE; /* out of memory */
187      pixels = tempImage;
188      srcFormat = GL_RGB;
189   }
190   else {
191      pixels = _mesa_image_address2d(srcPacking, srcAddr, srcWidth, srcHeight,
192                                     srcFormat, srcType, 0, 0);
193   }
194
195   dst = dstSlices[0];
196
197   if (ext_tx_compress_dxtn) {
198      (*ext_tx_compress_dxtn)(3, srcWidth, srcHeight, pixels,
199                              GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
200                              dst, dstRowStride);
201   }
202   else {
203      _mesa_warning(ctx, "external dxt library not available: texstore_rgb_dxt1");
204   }
205
206   if (tempImage)
207      free((void *) tempImage);
208
209   return GL_TRUE;
210}
211
212
213/**
214 * Store user's image in rgba_dxt1 format.
215 */
216GLboolean
217_mesa_texstore_rgba_dxt1(TEXSTORE_PARAMS)
218{
219   const GLubyte *pixels;
220   GLubyte *dst;
221   const GLubyte *tempImage = NULL;
222
223   ASSERT(dstFormat == MESA_FORMAT_RGBA_DXT1 ||
224          dstFormat == MESA_FORMAT_SRGBA_DXT1);
225
226   if (srcFormat != GL_RGBA ||
227       srcType != GL_UNSIGNED_BYTE ||
228       ctx->_ImageTransferState ||
229       srcPacking->RowLength != srcWidth ||
230       srcPacking->SwapBytes) {
231      /* convert image to RGBA/GLubyte */
232      tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
233                                             baseInternalFormat,
234                                             _mesa_get_format_base_format(dstFormat),
235                                             srcWidth, srcHeight, srcDepth,
236                                             srcFormat, srcType, srcAddr,
237                                             srcPacking);
238      if (!tempImage)
239         return GL_FALSE; /* out of memory */
240      pixels = tempImage;
241      srcFormat = GL_RGBA;
242   }
243   else {
244      pixels = _mesa_image_address2d(srcPacking, srcAddr, srcWidth, srcHeight,
245                                     srcFormat, srcType, 0, 0);
246   }
247
248   dst = dstSlices[0];
249
250   if (ext_tx_compress_dxtn) {
251      (*ext_tx_compress_dxtn)(4, srcWidth, srcHeight, pixels,
252                              GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
253                              dst, dstRowStride);
254   }
255   else {
256      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt1");
257   }
258
259   if (tempImage)
260      free((void*) tempImage);
261
262   return GL_TRUE;
263}
264
265
266/**
267 * Store user's image in rgba_dxt3 format.
268 */
269GLboolean
270_mesa_texstore_rgba_dxt3(TEXSTORE_PARAMS)
271{
272   const GLubyte *pixels;
273   GLubyte *dst;
274   const GLubyte *tempImage = NULL;
275
276   ASSERT(dstFormat == MESA_FORMAT_RGBA_DXT3 ||
277          dstFormat == MESA_FORMAT_SRGBA_DXT3);
278
279   if (srcFormat != GL_RGBA ||
280       srcType != GL_UNSIGNED_BYTE ||
281       ctx->_ImageTransferState ||
282       srcPacking->RowLength != srcWidth ||
283       srcPacking->SwapBytes) {
284      /* convert image to RGBA/GLubyte */
285      tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
286                                             baseInternalFormat,
287                                             _mesa_get_format_base_format(dstFormat),
288                                             srcWidth, srcHeight, srcDepth,
289                                             srcFormat, srcType, srcAddr,
290                                             srcPacking);
291      if (!tempImage)
292         return GL_FALSE; /* out of memory */
293      pixels = tempImage;
294   }
295   else {
296      pixels = _mesa_image_address2d(srcPacking, srcAddr, srcWidth, srcHeight,
297                                     srcFormat, srcType, 0, 0);
298   }
299
300   dst = dstSlices[0];
301
302   if (ext_tx_compress_dxtn) {
303      (*ext_tx_compress_dxtn)(4, srcWidth, srcHeight, pixels,
304                              GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
305                              dst, dstRowStride);
306   }
307   else {
308      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt3");
309   }
310
311   if (tempImage)
312      free((void *) tempImage);
313
314   return GL_TRUE;
315}
316
317
318/**
319 * Store user's image in rgba_dxt5 format.
320 */
321GLboolean
322_mesa_texstore_rgba_dxt5(TEXSTORE_PARAMS)
323{
324   const GLubyte *pixels;
325   GLubyte *dst;
326   const GLubyte *tempImage = NULL;
327
328   ASSERT(dstFormat == MESA_FORMAT_RGBA_DXT5 ||
329          dstFormat == MESA_FORMAT_SRGBA_DXT5);
330
331   if (srcFormat != GL_RGBA ||
332       srcType != GL_UNSIGNED_BYTE ||
333       ctx->_ImageTransferState ||
334       srcPacking->RowLength != srcWidth ||
335       srcPacking->SwapBytes) {
336      /* convert image to RGBA/GLubyte */
337      tempImage = _mesa_make_temp_ubyte_image(ctx, dims,
338                                             baseInternalFormat,
339                                   	     _mesa_get_format_base_format(dstFormat),
340                                             srcWidth, srcHeight, srcDepth,
341                                             srcFormat, srcType, srcAddr,
342                                             srcPacking);
343      if (!tempImage)
344         return GL_FALSE; /* out of memory */
345      pixels = tempImage;
346   }
347   else {
348      pixels = _mesa_image_address2d(srcPacking, srcAddr, srcWidth, srcHeight,
349                                     srcFormat, srcType, 0, 0);
350   }
351
352   dst = dstSlices[0];
353
354   if (ext_tx_compress_dxtn) {
355      (*ext_tx_compress_dxtn)(4, srcWidth, srcHeight, pixels,
356                              GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
357                              dst, dstRowStride);
358   }
359   else {
360      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt5");
361   }
362
363   if (tempImage)
364      free((void *) tempImage);
365
366   return GL_TRUE;
367}
368
369
370static void
371fetch_texel_2d_rgb_dxt1(const struct swrast_texture_image *texImage,
372                        GLint i, GLint j, GLint k, GLubyte *texel)
373{
374   (void) k;
375   if (fetch_ext_rgb_dxt1) {
376      GLint sliceOffset = k ? texImage->ImageOffsets[k] / 2 : 0;
377      fetch_ext_rgb_dxt1(texImage->RowStride,
378                         texImage->Map + sliceOffset, i, j, texel);
379   }
380   else
381      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgb_dxt1");
382}
383
384
385void
386_mesa_fetch_texel_rgb_dxt1(const struct swrast_texture_image *texImage,
387                           GLint i, GLint j, GLint k, GLfloat *texel)
388{
389   /* just sample as GLubyte and convert to float here */
390   GLubyte rgba[4];
391   fetch_texel_2d_rgb_dxt1(texImage, i, j, k, rgba);
392   texel[RCOMP] = UBYTE_TO_FLOAT(rgba[RCOMP]);
393   texel[GCOMP] = UBYTE_TO_FLOAT(rgba[GCOMP]);
394   texel[BCOMP] = UBYTE_TO_FLOAT(rgba[BCOMP]);
395   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
396}
397
398
399static void
400fetch_texel_2d_rgba_dxt1(const struct swrast_texture_image *texImage,
401                         GLint i, GLint j, GLint k, GLubyte *texel)
402{
403   (void) k;
404   if (fetch_ext_rgba_dxt1) {
405      GLint sliceOffset = k ? texImage->ImageOffsets[k] / 2 : 0;
406      fetch_ext_rgba_dxt1(texImage->RowStride,
407                          texImage->Map + sliceOffset, i, j, texel);
408   }
409   else
410      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt1\n");
411}
412
413
414void
415_mesa_fetch_texel_rgba_dxt1(const struct swrast_texture_image *texImage,
416                            GLint i, GLint j, GLint k, GLfloat *texel)
417{
418   /* just sample as GLubyte and convert to float here */
419   GLubyte rgba[4];
420   fetch_texel_2d_rgba_dxt1(texImage, i, j, k, rgba);
421   texel[RCOMP] = UBYTE_TO_FLOAT(rgba[RCOMP]);
422   texel[GCOMP] = UBYTE_TO_FLOAT(rgba[GCOMP]);
423   texel[BCOMP] = UBYTE_TO_FLOAT(rgba[BCOMP]);
424   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
425}
426
427
428static void
429fetch_texel_2d_rgba_dxt3(const struct swrast_texture_image *texImage,
430                         GLint i, GLint j, GLint k, GLubyte *texel)
431{
432   (void) k;
433   if (fetch_ext_rgba_dxt3) {
434      GLint sliceOffset = k ? texImage->ImageOffsets[k] : 0;
435      fetch_ext_rgba_dxt3(texImage->RowStride,
436                          texImage->Map + sliceOffset, i, j, texel);
437   }
438   else
439      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt3\n");
440}
441
442
443void
444_mesa_fetch_texel_rgba_dxt3(const struct swrast_texture_image *texImage,
445                            GLint i, GLint j, GLint k, GLfloat *texel)
446{
447   /* just sample as GLubyte and convert to float here */
448   GLubyte rgba[4];
449   fetch_texel_2d_rgba_dxt3(texImage, i, j, k, rgba);
450   texel[RCOMP] = UBYTE_TO_FLOAT(rgba[RCOMP]);
451   texel[GCOMP] = UBYTE_TO_FLOAT(rgba[GCOMP]);
452   texel[BCOMP] = UBYTE_TO_FLOAT(rgba[BCOMP]);
453   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
454}
455
456
457static void
458fetch_texel_2d_rgba_dxt5(const struct swrast_texture_image *texImage,
459                         GLint i, GLint j, GLint k, GLubyte *texel)
460{
461   (void) k;
462   if (fetch_ext_rgba_dxt5) {
463      GLint sliceOffset = k ? texImage->ImageOffsets[k] : 0;
464      fetch_ext_rgba_dxt5(texImage->RowStride,
465                          texImage->Map + sliceOffset, i, j, texel);
466   }
467   else
468      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt5\n");
469}
470
471
472void
473_mesa_fetch_texel_rgba_dxt5(const struct swrast_texture_image *texImage,
474                            GLint i, GLint j, GLint k, GLfloat *texel)
475{
476   /* just sample as GLubyte and convert to float here */
477   GLubyte rgba[4];
478   fetch_texel_2d_rgba_dxt5(texImage, i, j, k, rgba);
479   texel[RCOMP] = UBYTE_TO_FLOAT(rgba[RCOMP]);
480   texel[GCOMP] = UBYTE_TO_FLOAT(rgba[GCOMP]);
481   texel[BCOMP] = UBYTE_TO_FLOAT(rgba[BCOMP]);
482   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
483}
484
485#if FEATURE_EXT_texture_sRGB
486void
487_mesa_fetch_texel_srgb_dxt1(const struct swrast_texture_image *texImage,
488                            GLint i, GLint j, GLint k, GLfloat *texel)
489{
490   /* just sample as GLubyte and convert to float here */
491   GLubyte rgba[4];
492   fetch_texel_2d_rgb_dxt1(texImage, i, j, k, rgba);
493   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
494   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
495   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
496   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
497}
498
499void
500_mesa_fetch_texel_srgba_dxt1(const struct swrast_texture_image *texImage,
501                             GLint i, GLint j, GLint k, GLfloat *texel)
502{
503   /* just sample as GLubyte and convert to float here */
504   GLubyte rgba[4];
505   fetch_texel_2d_rgba_dxt1(texImage, i, j, k, rgba);
506   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
507   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
508   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
509   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
510}
511
512void
513_mesa_fetch_texel_srgba_dxt3(const struct swrast_texture_image *texImage,
514                             GLint i, GLint j, GLint k, GLfloat *texel)
515{
516   /* just sample as GLubyte and convert to float here */
517   GLubyte rgba[4];
518   fetch_texel_2d_rgba_dxt3(texImage, i, j, k, rgba);
519   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
520   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
521   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
522   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
523}
524
525void
526_mesa_fetch_texel_srgba_dxt5(const struct swrast_texture_image *texImage,
527                             GLint i, GLint j, GLint k, GLfloat *texel)
528{
529   /* just sample as GLubyte and convert to float here */
530   GLubyte rgba[4];
531   fetch_texel_2d_rgba_dxt5(texImage, i, j, k, rgba);
532   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
533   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
534   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
535   texel[ACOMP] = UBYTE_TO_FLOAT(rgba[ACOMP]);
536}
537#endif /* FEATURE_EXT_texture_sRGB */
538
539
540#endif /* FEATURE_texture_s3tc */
541