#include "imports.h"
#include "context.h"
#include "version.h"
#define MAXSTRING 4000
#ifdef WIN32
#define vsnprintf _vsnprintf
#elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )
extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
#ifdef __VMS
#include "vsnprintf.c"
#endif
#endif
#ifdef NO_LIBCWRAPPER
#undef IN_MODULE
#endif
void *
_mesa_malloc(size_t bytes)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86malloc(bytes);
#else
return malloc(bytes);
#endif
}
void *
_mesa_calloc(size_t bytes)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86calloc(1, bytes);
#else
return calloc(1, bytes);
#endif
}
void
_mesa_free(void *ptr)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86free(ptr);
#else
free(ptr);
#endif
}
void *
_mesa_align_malloc(size_t bytes, unsigned long alignment)
{
#if defined(HAVE_POSIX_MEMALIGN) && !(defined(XFree86LOADER) && defined(IN_MODULE))
void *mem;
(void) posix_memalign(& mem, alignment, bytes);
return mem;
#else
uintptr_t ptr, buf;
ASSERT( alignment > 0 );
ptr = (uintptr_t) _mesa_malloc(bytes + alignment + sizeof(void *));
if (!ptr)
return NULL;
buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
*(uintptr_t *)(buf - sizeof(void *)) = ptr;
#ifdef DEBUG
while ( ptr < buf - sizeof(void *) ) {
*(unsigned long *)ptr = 0xcdcdcdcd;
ptr += sizeof(unsigned long);
}
#endif
return (void *) buf;
#endif
}
void *
_mesa_align_calloc(size_t bytes, unsigned long alignment)
{
#if defined(HAVE_POSIX_MEMALIGN) && !(defined(XFree86LOADER) && defined(IN_MODULE))
void *mem;
mem = _mesa_align_malloc(bytes, alignment);
if (mem != NULL) {
(void) memset(mem, 0, bytes);
}
return mem;
#else
uintptr_t ptr, buf;
ASSERT( alignment > 0 );
ptr = (uintptr_t) _mesa_calloc(bytes + alignment + sizeof(void *));
if (!ptr)
return NULL;
buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
*(uintptr_t *)(buf - sizeof(void *)) = ptr;
#ifdef DEBUG
while ( ptr < buf - sizeof(void *) ) {
*(unsigned long *)ptr = 0xcdcdcdcd;
ptr += sizeof(unsigned long);
}
#endif
return (void *)buf;
#endif
}
void
_mesa_align_free(void *ptr)
{
#if defined(HAVE_POSIX_MEMALIGN) && !(defined(XFree86LOADER) && defined(IN_MODULE))
free(ptr);
#else
void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
void *realAddr = *cubbyHole;
_mesa_free(realAddr);
#endif
}
void *
_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
unsigned long alignment)
{
const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
void *newBuf = _mesa_align_malloc(newSize, alignment);
if (newBuf && oldBuffer && copySize > 0) {
_mesa_memcpy(newBuf, oldBuffer, copySize);
}
if (oldBuffer)
_mesa_align_free(oldBuffer);
return newBuf;
}
void *
_mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize)
{
const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
void *newBuffer = _mesa_malloc(newSize);
if (newBuffer && oldBuffer && copySize > 0)
_mesa_memcpy(newBuffer, oldBuffer, copySize);
if (oldBuffer)
_mesa_free(oldBuffer);
return newBuffer;
}
void *
_mesa_memcpy(void *dest, const void *src, size_t n)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86memcpy(dest, src, n);
#elif defined(SUNOS4)
return memcpy((char *) dest, (char *) src, (int) n);
#else
return memcpy(dest, src, n);
#endif
}
void
_mesa_memset( void *dst, int val, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86memset( dst, val, n );
#elif defined(SUNOS4)
memset( (char *) dst, (int) val, (int) n );
#else
memset(dst, val, n);
#endif
}
void
_mesa_memset16( unsigned short *dst, unsigned short val, size_t n )
{
while (n-- > 0)
*dst++ = val;
}
void
_mesa_bzero( void *dst, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86memset( dst, 0, n );
#elif defined(__FreeBSD__)
bzero( dst, n );
#else
memset( dst, 0, n );
#endif
}
int
_mesa_memcmp( const void *s1, const void *s2, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86memcmp( s1, s2, n );
#elif defined(SUNOS4)
return memcmp( (char *) s1, (char *) s2, (int) n );
#else
return memcmp(s1, s2, n);
#endif
}
double
_mesa_sin(double a)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86sin(a);
#else
return sin(a);
#endif
}
float
_mesa_sinf(float a)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return (float) xf86sin((double) a);
#else
return (float) sin((double) a);
#endif
}
double
_mesa_cos(double a)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86cos(a);
#else
return cos(a);
#endif
}
float
_mesa_asinf(float x)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return (float) xf86asin((double) x);
#else
return (float) asin((double) x);
#endif
}
float
_mesa_atanf(float x)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return (float) xf86atan((double) x);
#else
return (float) atan((double) x);
#endif
}
double
_mesa_sqrtd(double x)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86sqrt(x);
#else
return sqrt(x);
#endif
}
static short sqrttab[0x100];
static void init_sqrt_table(void)
{
#if defined(USE_IEEE) && !defined(DEBUG)
unsigned short i;
fi_type fi;
for(i=0; i<= 0x7f; i++) {
fi.i = 0;
fi.i = (i << 16) | (127 << 23);
fi.f = _mesa_sqrtd(fi.f);
sqrttab[i] = (fi.i & 0x7fffff) >> 16;
fi.i = 0;
fi.i = (i << 16) | (128 << 23);
fi.f = sqrt(fi.f);
sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
}
#else
(void) sqrttab;
#endif
}
float
_mesa_sqrtf( float x )
{
#if defined(USE_IEEE) && !defined(DEBUG)
fi_type num;
short e;
if (x == 0.0F) return 0.0F;
num.f = x;
e = (num.i >> 23) - 127;
num.i &= 0x7fffff;
if (e & 0x01) num.i |= 0x800000;
e >>= 1;
num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
return num.f;
#else
return (float) _mesa_sqrtd((double) x);
#endif
}
float
_mesa_inv_sqrtf(float n)
{
#if defined(USE_IEEE) && !defined(DEBUG)
float r0, x0, y0;
float r1, x1, y1;
float r2, x2, y2;
#if 0
float r3, x3, y3;
#endif
union { float f; unsigned int i; } u;
unsigned int magic;
magic = 381 << 23;
magic -= (int)(0.0332281 * (1 << 25));
u.f = n;
u.i = (magic - u.i) >> 1;
x0 = 1.0f;
y0 = 0.5f * n;
r0 = u.f;
x1 = x0 * r0;
y1 = y0 * r0 * r0;
r1 = 1.5f - y1;
x2 = x1 * r1;
y2 = y1 * r1 * r1;
r2 = 1.5f - y2;
#if 1
return x2 * r2;
#else
x3 = x2 * r2;
y3 = y2 * r2 * r2;
r3 = 1.5f - y3;
return x3 * r3;
#endif
#elif defined(XFree86LOADER) && defined(IN_MODULE)
return 1.0F / xf86sqrt(n);
#else
return (float) (1.0 / sqrt(n));
#endif
}
double
_mesa_pow(double x, double y)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86pow(x, y);
#else
return pow(x, y);
#endif
}
int
_mesa_ffs(int i)
{
#if (defined(_WIN32) && !defined(__MINGW32__) ) || defined(__IBMC__) || defined(__IBMCPP__)
register int bit = 0;
if (i != 0) {
if ((i & 0xffff) == 0) {
bit += 16;
i >>= 16;
}
if ((i & 0xff) == 0) {
bit += 8;
i >>= 8;
}
if ((i & 0xf) == 0) {
bit += 4;
i >>= 4;
}
while ((i & 1) == 0) {
bit++;
i >>= 1;
}
}
return bit;
#elif defined(XFree86LOADER) && defined(IN_MODULE)
return xf86ffs(i);
#else
return ffs(i);
#endif
}
unsigned int
_mesa_bitcount(unsigned int n)
{
unsigned int bits;
for (bits = 0; n > 0; n = n >> 1) {
bits += (n & 1);
}
return bits;
}
GLhalfARB
_mesa_float_to_half(float val)
{
const int flt = *((int *) (void *) &val);
const int flt_m = flt & 0x7fffff;
const int flt_e = (flt >> 23) & 0xff;
const int flt_s = (flt >> 31) & 0x1;
int s, e, m = 0;
GLhalfARB result;
s = flt_s;
if ((flt_e == 0) && (flt_m == 0)) {
e = 0;
}
else if ((flt_e == 0) && (flt_m != 0)) {
e = 0;
}
else if ((flt_e == 0xff) && (flt_m == 0)) {
e = 31;
}
else if ((flt_e == 0xff) && (flt_m != 0)) {
m = 1;
e = 31;
}
else {
const int new_exp = flt_e - 127;
if (new_exp < -24) {
e = 0;
}
else if (new_exp < -14) {
unsigned int exp_val = (unsigned int) (-14 - new_exp);
e = 0;
switch (exp_val) {
case 0:
_mesa_warning(NULL,
"float_to_half: logical error in denorm creation!\n");
break;
case 1: m = 512 + (flt_m >> 14); break;
case 2: m = 256 + (flt_m >> 15); break;
case 3: m = 128 + (flt_m >> 16); break;
case 4: m = 64 + (flt_m >> 17); break;
case 5: m = 32 + (flt_m >> 18); break;
case 6: m = 16 + (flt_m >> 19); break;
case 7: m = 8 + (flt_m >> 20); break;
case 8: m = 4 + (flt_m >> 21); break;
case 9: m = 2 + (flt_m >> 22); break;
case 10: m = 1; break;
}
}
else if (new_exp > 15) {
e = 31;
}
else {
e = new_exp + 15;
m = flt_m >> 13;
}
}
result = (s << 15) | (e << 10) | m;
return result;
}
float
_mesa_half_to_float(GLhalfARB val)
{
const int m = val & 0x3ff;
const int e = (val >> 10) & 0x1f;
const int s = (val >> 15) & 0x1;
int flt_m, flt_e, flt_s, flt;
float result;
flt_s = s;
if ((e == 0) && (m == 0)) {
flt_m = 0;
flt_e = 0;
}
else if ((e == 0) && (m != 0)) {
const float half_denorm = 1.0f / 16384.0f;
float mantissa = ((float) (m)) / 1024.0f;
float sign = s ? -1.0f : 1.0f;
return sign * mantissa * half_denorm;
}
else if ((e == 31) && (m == 0)) {
flt_e = 0xff;
flt_m = 0;
}
else if ((e == 31) && (m != 0)) {
flt_e = 0xff;
flt_m = 1;
}
else {
flt_e = e + 112;
flt_m = m << 13;
}
flt = (flt_s << 31) | (flt_e << 23) | flt_m;
result = *((float *) (void *) &flt);
return result;
}
void *
_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size,
int (*compar)(const void *, const void *) )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86bsearch(key, base, nmemb, size, compar);
#else
return bsearch(key, base, nmemb, size, compar);
#endif
}
char *
_mesa_getenv( const char *var )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86getenv(var);
#elif defined(_XBOX)
return NULL;
#else
return getenv(var);
#endif
}
char *
_mesa_strstr( const char *haystack, const char *needle )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strstr(haystack, needle);
#else
return strstr(haystack, needle);
#endif
}
char *
_mesa_strncat( char *dest, const char *src, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strncat(dest, src, n);
#else
return strncat(dest, src, n);
#endif
}
char *
_mesa_strcpy( char *dest, const char *src )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strcpy(dest, src);
#else
return strcpy(dest, src);
#endif
}
char *
_mesa_strncpy( char *dest, const char *src, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strncpy(dest, src, n);
#else
return strncpy(dest, src, n);
#endif
}
size_t
_mesa_strlen( const char *s )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strlen(s);
#else
return strlen(s);
#endif
}
int
_mesa_strcmp( const char *s1, const char *s2 )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strcmp(s1, s2);
#else
return strcmp(s1, s2);
#endif
}
int
_mesa_strncmp( const char *s1, const char *s2, size_t n )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strncmp(s1, s2, n);
#else
return strncmp(s1, s2, n);
#endif
}
char *
_mesa_strdup( const char *s )
{
size_t l = _mesa_strlen(s);
char *s2 = (char *) _mesa_malloc(l + 1);
if (s2)
_mesa_strcpy(s2, s);
return s2;
}
int
_mesa_atoi(const char *s)
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86atoi(s);
#else
return atoi(s);
#endif
}
double
_mesa_strtod( const char *s, char **end )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86strtod(s, end);
#else
return strtod(s, end);
#endif
}
int
_mesa_sprintf( char *str, const char *fmt, ... )
{
int r;
va_list args;
va_start( args, fmt );
#if defined(XFree86LOADER) && defined(IN_MODULE)
r = xf86vsprintf( str, fmt, args );
#else
r = vsprintf( str, fmt, args );
#endif
va_end( args );
return r;
}
void
_mesa_printf( const char *fmtString, ... )
{
char s[MAXSTRING];
va_list args;
va_start( args, fmtString );
vsnprintf(s, MAXSTRING, fmtString, args);
va_end( args );
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86printf("%s", s);
#else
fprintf(stderr,"%s", s);
#endif
}
int
_mesa_vsprintf( char *str, const char *fmt, va_list args )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86vsprintf( str, fmt, args );
#else
return vsprintf( str, fmt, args );
#endif
}
void
_mesa_warning( GLcontext *ctx, const char *fmtString, ... )
{
GLboolean debug;
char str[MAXSTRING];
va_list args;
(void) ctx;
va_start( args, fmtString );
(void) vsnprintf( str, MAXSTRING, fmtString, args );
va_end( args );
#ifdef DEBUG
debug = GL_TRUE;
#else
debug = _mesa_getenv("MESA_DEBUG") ? GL_TRUE : GL_FALSE;
#endif
if (debug) {
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86fprintf(stderr, "Mesa warning: %s\n", str);
#else
fprintf(stderr, "Mesa warning: %s\n", str);
#endif
}
}
void
_mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
{
va_list args;
char str[MAXSTRING];
(void) ctx;
va_start( args, fmtString );
vsnprintf( str, MAXSTRING, fmtString, args );
va_end( args );
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
xf86fprintf(stderr, "Please report at bugzilla.freedesktop.org\n");
#else
fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
fprintf(stderr, "Please report at bugzilla.freedesktop.org\n");
#endif
}
void
_mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... )
{
const char *debugEnv;
GLboolean debug;
debugEnv = _mesa_getenv("MESA_DEBUG");
#ifdef DEBUG
if (debugEnv && _mesa_strstr(debugEnv, "silent"))
debug = GL_FALSE;
else
debug = GL_TRUE;
#else
if (debugEnv)
debug = GL_TRUE;
else
debug = GL_FALSE;
#endif
if (debug) {
va_list args;
char where[MAXSTRING];
const char *errstr;
va_start( args, fmtString );
vsnprintf( where, MAXSTRING, fmtString, args );
va_end( args );
switch (error) {
case GL_NO_ERROR:
errstr = "GL_NO_ERROR";
break;
case GL_INVALID_VALUE:
errstr = "GL_INVALID_VALUE";
break;
case GL_INVALID_ENUM:
errstr = "GL_INVALID_ENUM";
break;
case GL_INVALID_OPERATION:
errstr = "GL_INVALID_OPERATION";
break;
case GL_STACK_OVERFLOW:
errstr = "GL_STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
errstr = "GL_STACK_UNDERFLOW";
break;
case GL_OUT_OF_MEMORY:
errstr = "GL_OUT_OF_MEMORY";
break;
case GL_TABLE_TOO_LARGE:
errstr = "GL_TABLE_TOO_LARGE";
break;
case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
errstr = "GL_INVALID_FRAMEBUFFER_OPERATION";
break;
default:
errstr = "unknown";
break;
}
_mesa_debug(ctx, "User error: %s in %s\n", errstr, where);
}
_mesa_record_error(ctx, error);
}
void
_mesa_debug( const GLcontext *ctx, const char *fmtString, ... )
{
#ifdef DEBUG
char s[MAXSTRING];
va_list args;
va_start(args, fmtString);
vsnprintf(s, MAXSTRING, fmtString, args);
va_end(args);
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86fprintf(stderr, "Mesa: %s", s);
#else
fprintf(stderr, "Mesa: %s", s);
#endif
#endif
(void) ctx;
(void) fmtString;
}
void
_mesa_exit( int status )
{
#if defined(XFree86LOADER) && defined(IN_MODULE)
xf86exit(status);
#else
exit(status);
#endif
}
static void *
default_malloc(__GLcontext *gc, size_t size)
{
(void) gc;
return _mesa_malloc(size);
}
static void *
default_calloc(__GLcontext *gc, size_t numElem, size_t elemSize)
{
(void) gc;
return _mesa_calloc(numElem * elemSize);
}
static void *
default_realloc(__GLcontext *gc, void *oldAddr, size_t newSize)
{
(void) gc;
#if defined(XFree86LOADER) && defined(IN_MODULE)
return xf86realloc(oldAddr, newSize);
#else
return realloc(oldAddr, newSize);
#endif
}
static void
default_free(__GLcontext *gc, void *addr)
{
(void) gc;
_mesa_free(addr);
}
static char * CAPI
default_getenv( __GLcontext *gc, const char *var )
{
(void) gc;
return _mesa_getenv(var);
}
static void
default_warning(__GLcontext *gc, char *str)
{
_mesa_warning(gc, str);
}
static void
default_fatal(__GLcontext *gc, char *str)
{
_mesa_problem(gc, str);
abort();
}
static int CAPI
default_atoi(__GLcontext *gc, const char *str)
{
(void) gc;
return atoi(str);
}
static int CAPI
default_sprintf(__GLcontext *gc, char *str, const char *fmt, ...)
{
int r;
va_list args;
(void) gc;
va_start( args, fmt );
r = vsprintf( str, fmt, args );
va_end( args );
return r;
}
static void * CAPI
default_fopen(__GLcontext *gc, const char *path, const char *mode)
{
(void) gc;
return fopen(path, mode);
}
static int CAPI
default_fclose(__GLcontext *gc, void *stream)
{
(void) gc;
return fclose((FILE *) stream);
}
static int CAPI
default_fprintf(__GLcontext *gc, void *stream, const char *fmt, ...)
{
int r;
va_list args;
(void) gc;
va_start( args, fmt );
r = vfprintf( (FILE *) stream, fmt, args );
va_end( args );
return r;
}
static __GLdrawablePrivate *
default_GetDrawablePrivate(__GLcontext *gc)
{
(void) gc;
return NULL;
}
void
_mesa_init_default_imports(__GLimports *imports, void *driverCtx)
{
static GLboolean initialized = GL_FALSE;
if (!initialized) {
init_sqrt_table();
initialized = GL_TRUE;
}
imports->malloc = default_malloc;
imports->calloc = default_calloc;
imports->realloc = default_realloc;
imports->free = default_free;
imports->warning = default_warning;
imports->fatal = default_fatal;
imports->getenv = default_getenv;
imports->atoi = default_atoi;
imports->sprintf = default_sprintf;
imports->fopen = default_fopen;
imports->fclose = default_fclose;
imports->fprintf = default_fprintf;
imports->getDrawablePrivate = default_GetDrawablePrivate;
imports->other = driverCtx;
}