OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

glsl: move half<->float convertion to util

Browse Source 
Needed in NIR too, so move out of mesa/main/imports.c

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Reviewed-by: Emil Velikov <emil.velikov@collabora.com>
Signed-off-by: Rob Clark <robclark@freedesktop.org>
This commit is contained in:
Rob Clark
2015-10-10 13:26:03 -04:00
parent 60690cb3b3
commit 183db3a645
13 changed files with 228 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/glsl/Makefile.am
View File

@@ -160,6 +160,7 @@ glsl_compiler_SOURCES = \
glsl_compiler_LDADD = \ glsl_compiler_LDADD = \
libglsl.la \ libglsl.la \
$(top_builddir)/src/libglsl_util.la \ $(top_builddir)/src/libglsl_util.la \
$(top_builddir)/src/util/libmesautil.la \
$(PTHREAD_LIBS) $(PTHREAD_LIBS)
glsl_test_SOURCES = \ glsl_test_SOURCES = \

1
src/glsl/ir_constant_expression.cpp
View File

@@ -36,6 +36,7 @@
#include <math.h> #include <math.h>
#include "main/core.h" /* for MAX2, MIN2, CLAMP */ #include "main/core.h" /* for MAX2, MIN2, CLAMP */
#include "util/rounding.h" /* for _mesa_roundeven */ #include "util/rounding.h" /* for _mesa_roundeven */
#include "util/half_float.h"
#include "ir.h" #include "ir.h"
#include "glsl_types.h" #include "glsl_types.h"
#include "program/hash_table.h" #include "program/hash_table.h"

1
src/glsl/nir/nir_constant_expressions.py
View File

@@ -29,6 +29,7 @@ template = """\
#include <math.h> #include <math.h>
#include "main/core.h" #include "main/core.h"
#include "util/rounding.h" /* for _mesa_roundeven */ #include "util/rounding.h" /* for _mesa_roundeven */
#include "util/half_float.h"
#include "nir_constant_expressions.h" #include "nir_constant_expressions.h"
#if defined(__SUNPRO_CC) #if defined(__SUNPRO_CC)

1
src/mesa/drivers/dri/i965/brw_sampler_state.c
View File

@@ -44,6 +44,7 @@
#include "main/macros.h" #include "main/macros.h"
#include "main/samplerobj.h" #include "main/samplerobj.h"
#include "util/half_float.h"
/** /**
* Emit a 3DSTATE_SAMPLER_STATE_POINTERS_{VS,HS,GS,DS,PS} packet. * Emit a 3DSTATE_SAMPLER_STATE_POINTERS_{VS,HS,GS,DS,PS} packet.

1
src/mesa/main/format_utils.h
View File

@@ -34,6 +34,7 @@
#include "imports.h" #include "imports.h"
#include "macros.h" #include "macros.h"
#include "util/rounding.h" #include "util/rounding.h"
#include "util/half_float.h"
extern const mesa_array_format RGBA32_FLOAT; extern const mesa_array_format RGBA32_FLOAT;
extern const mesa_array_format RGBA8_UBYTE; extern const mesa_array_format RGBA8_UBYTE;

148
src/mesa/main/imports.c
View File

@@ -307,154 +307,6 @@ _mesa_bitcount_64(uint64_t n)
} }
#endif #endif
/**
* Convert a 4-byte float to a 2-byte half float.
*
* Not all float32 values can be represented exactly as a float16 value. We
* round such intermediate float32 values to the nearest float16. When the
* float32 lies exactly between to float16 values, we round to the one with
* an even mantissa.
*
* This rounding behavior has several benefits:
* - It has no sign bias.
*
* - It reproduces the behavior of real hardware: opcode F32TO16 in Intel's
* GPU ISA.
*
* - By reproducing the behavior of the GPU (at least on Intel hardware),
* compile-time evaluation of constant packHalf2x16 GLSL expressions will
* result in the same value as if the expression were executed on the GPU.
*/
GLhalfARB
_mesa_float_to_half(float val)
{
const fi_type fi = {val};
const int flt_m = fi.i & 0x7fffff;
const int flt_e = (fi.i >> 23) & 0xff;
const int flt_s = (fi.i >> 31) & 0x1;
int s, e, m = 0;
GLhalfARB result;
/* sign bit */
s = flt_s;
/* handle special cases */
if ((flt_e == 0) && (flt_m == 0)) {
/* zero */
/* m = 0; - already set */
e = 0;
}
else if ((flt_e == 0) && (flt_m != 0)) {
/* denorm -- denorm float maps to 0 half */
/* m = 0; - already set */
e = 0;
}
else if ((flt_e == 0xff) && (flt_m == 0)) {
/* infinity */
/* m = 0; - already set */
e = 31;
}
else if ((flt_e == 0xff) && (flt_m != 0)) {
/* NaN */
m = 1;
e = 31;
}
else {
/* regular number */
const int new_exp = flt_e - 127;
if (new_exp < -14) {
/* The float32 lies in the range (0.0, min_normal16) and is rounded
* to a nearby float16 value. The result will be either zero, subnormal,
* or normal.
*/
e = 0;
m = _mesa_lroundevenf((1 << 24) * fabsf(fi.f));
}
else if (new_exp > 15) {
/* map this value to infinity */
/* m = 0; - already set */
e = 31;
}
else {
/* The float32 lies in the range
* [min_normal16, max_normal16 + max_step16)
* and is rounded to a nearby float16 value. The result will be
* either normal or infinite.
*/
e = new_exp + 15;
m = _mesa_lroundevenf(flt_m / (float) (1 << 13));
}
}
assert(0 <= m && m <= 1024);
if (m == 1024) {
/* The float32 was rounded upwards into the range of the next exponent,
* so bump the exponent. This correctly handles the case where f32
* should be rounded up to float16 infinity.
*/
++e;
m = 0;
}
result = (s << 15) | (e << 10) | m;
return result;
}
/**
* Convert a 2-byte half float to a 4-byte float.
* Based on code from:
* http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
*/
float
_mesa_half_to_float(GLhalfARB val)
{
/* XXX could also use a 64K-entry lookup table */
const int m = val & 0x3ff;
const int e = (val >> 10) & 0x1f;
const int s = (val >> 15) & 0x1;
int flt_m, flt_e, flt_s;
fi_type fi;
float result;
/* sign bit */
flt_s = s;
/* handle special cases */
if ((e == 0) && (m == 0)) {
/* zero */
flt_m = 0;
flt_e = 0;
}
else if ((e == 0) && (m != 0)) {
/* denorm -- denorm half will fit in non-denorm single */
const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
float mantissa = ((float) (m)) / 1024.0f;
float sign = s ? -1.0f : 1.0f;
return sign * mantissa * half_denorm;
}
else if ((e == 31) && (m == 0)) {
/* infinity */
flt_e = 0xff;
flt_m = 0;
}
else if ((e == 31) && (m != 0)) {
/* NaN */
flt_e = 0xff;
flt_m = 1;
}
else {
/* regular */
flt_e = e + 112;
flt_m = m << 13;
}
fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;
result = fi.f;
return result;
}
/*@}*/ /*@}*/

7
src/mesa/main/imports.h
View File

@@ -396,13 +396,6 @@ _mesa_flsll(uint64_t n)
#endif #endif
} }
extern GLhalfARB
_mesa_float_to_half(float f);
extern float
_mesa_half_to_float(GLhalfARB h);
static inline bool static inline bool
_mesa_half_is_negative(GLhalfARB h) _mesa_half_is_negative(GLhalfARB h)
{ {

1
src/mesa/main/mipmap.c
View File

@@ -37,6 +37,7 @@
#include "texstore.h" #include "texstore.h"
#include "image.h" #include "image.h"
#include "macros.h" #include "macros.h"
#include "util/half_float.h"
#include "../../gallium/auxiliary/util/u_format_rgb9e5.h" #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h" #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"

1
src/mesa/main/texcompress_bptc.c
View File

@@ -30,6 +30,7 @@
#include "texcompress.h" #include "texcompress.h"
#include "texcompress_bptc.h" #include "texcompress_bptc.h"
#include "util/format_srgb.h" #include "util/format_srgb.h"
#include "util/half_float.h"
#include "texstore.h" #include "texstore.h"
#include "macros.h" #include "macros.h"
#include "image.h" #include "image.h"

1
src/mesa/tnl/t_draw.c
View File

@@ -35,6 +35,7 @@
#include "main/mtypes.h" #include "main/mtypes.h"
#include "main/macros.h" #include "main/macros.h"
#include "main/enums.h" #include "main/enums.h"
#include "util/half_float.h"
#include "t_context.h" #include "t_context.h"
#include "tnl.h" #include "tnl.h"

2
src/util/Makefile.sources
View File

@@ -3,6 +3,8 @@ MESA_UTIL_FILES := \
debug.c \ debug.c \
debug.h \ debug.h \
format_srgb.h \ format_srgb.h \
half_float.c \
half_float.h \
hash_table.c \ hash_table.c \
hash_table.h \ hash_table.h \
list.h \ list.h \

177
src/util/half_float.c Normal file
View File

@@ -0,0 +1,177 @@
/*
* Mesa 3-D graphics library
*
* Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include <math.h>
#include <assert.h>
#include "half_float.h"
#include "rounding.h"
typedef union { float f; int32_t i; uint32_t u; } fi_type;
/**
* Convert a 4-byte float to a 2-byte half float.
*
* Not all float32 values can be represented exactly as a float16 value. We
* round such intermediate float32 values to the nearest float16. When the
* float32 lies exactly between to float16 values, we round to the one with
* an even mantissa.
*
* This rounding behavior has several benefits:
* - It has no sign bias.
*
* - It reproduces the behavior of real hardware: opcode F32TO16 in Intel's
* GPU ISA.
*
* - By reproducing the behavior of the GPU (at least on Intel hardware),
* compile-time evaluation of constant packHalf2x16 GLSL expressions will
* result in the same value as if the expression were executed on the GPU.
*/
uint16_t
_mesa_float_to_half(float val)
{
const fi_type fi = {val};
const int flt_m = fi.i & 0x7fffff;
const int flt_e = (fi.i >> 23) & 0xff;
const int flt_s = (fi.i >> 31) & 0x1;
int s, e, m = 0;
uint16_t result;
/* sign bit */
s = flt_s;
/* handle special cases */
if ((flt_e == 0) && (flt_m == 0)) {
/* zero */
/* m = 0; - already set */
e = 0;
}
else if ((flt_e == 0) && (flt_m != 0)) {
/* denorm -- denorm float maps to 0 half */
/* m = 0; - already set */
e = 0;
}
else if ((flt_e == 0xff) && (flt_m == 0)) {
/* infinity */
/* m = 0; - already set */
e = 31;
}
else if ((flt_e == 0xff) && (flt_m != 0)) {
/* NaN */
m = 1;
e = 31;
}
else {
/* regular number */
const int new_exp = flt_e - 127;
if (new_exp < -14) {
/* The float32 lies in the range (0.0, min_normal16) and is rounded
* to a nearby float16 value. The result will be either zero, subnormal,
* or normal.
*/
e = 0;
m = _mesa_lroundevenf((1 << 24) * fabsf(fi.f));
}
else if (new_exp > 15) {
/* map this value to infinity */
/* m = 0; - already set */
e = 31;
}
else {
/* The float32 lies in the range
* [min_normal16, max_normal16 + max_step16)
* and is rounded to a nearby float16 value. The result will be
* either normal or infinite.
*/
e = new_exp + 15;
m = _mesa_lroundevenf(flt_m / (float) (1 << 13));
}
}
assert(0 <= m && m <= 1024);
if (m == 1024) {
/* The float32 was rounded upwards into the range of the next exponent,
* so bump the exponent. This correctly handles the case where f32
* should be rounded up to float16 infinity.
*/
++e;
m = 0;
}
result = (s << 15) | (e << 10) | m;
return result;
}
/**
* Convert a 2-byte half float to a 4-byte float.
* Based on code from:
* http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
*/
float
_mesa_half_to_float(uint16_t val)
{
/* XXX could also use a 64K-entry lookup table */
const int m = val & 0x3ff;
const int e = (val >> 10) & 0x1f;
const int s = (val >> 15) & 0x1;
int flt_m, flt_e, flt_s;
fi_type fi;
float result;
/* sign bit */
flt_s = s;
/* handle special cases */
if ((e == 0) && (m == 0)) {
/* zero */
flt_m = 0;
flt_e = 0;
}
else if ((e == 0) && (m != 0)) {
/* denorm -- denorm half will fit in non-denorm single */
const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
float mantissa = ((float) (m)) / 1024.0f;
float sign = s ? -1.0f : 1.0f;
return sign * mantissa * half_denorm;
}
else if ((e == 31) && (m == 0)) {
/* infinity */
flt_e = 0xff;
flt_m = 0;
}
else if ((e == 31) && (m != 0)) {
/* NaN */
flt_e = 0xff;
flt_m = 1;
}
else {
/* regular */
flt_e = e + 112;
flt_m = m << 13;
}
fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;
result = fi.f;
return result;
}

41
src/util/half_float.h Normal file
View File

@@ -0,0 +1,41 @@
/*
* Mesa 3-D graphics library
*
* Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _HALF_FLOAT_H_
#define _HALF_FLOAT_H_
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
uint16_t _mesa_float_to_half(float val);
float _mesa_half_to_float(uint16_t val);
#ifdef __cplusplus
} /* extern C */
#endif
#endif /* _HALF_FLOAT_H_ */