external/openglcts/modules/common/glcMisc.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * OpenGL Conformance Test Suite
  * -----------------------------
  *
  * Copyright (c) 2017 The Khronos Group Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  */ /*!
  * \file glcMisc.cpp
  * \brief Miscellaneous helper functions.
  */ /*-------------------------------------------------------------------*/

 #include "glcMisc.hpp"

 using namespace glw;

 namespace glcts
 {

 /* utility functions from the book OpenGL ES 2.0 Programming Guide */
 /* -15 stored using a single precision bias of 127 */
 const unsigned int HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
 /* max exponent value in single precision that will be converted */
 /* to Inf or Nan when stored as a half-float */
 const unsigned int HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
 /* 255 is the max exponent biased value */
 const unsigned int FLOAT_MAX_BIASED_EXP		 = (0xFF << 23);
 const unsigned int HALF_FLOAT_MAX_BIASED_EXP = (0x1F << 10);

 GLhalf floatToHalfFloat(float f)
 {
 	union {
 		float		 v;
 		unsigned int x;
 	};
 	v				  = f;
 	unsigned int sign = (GLhalf)(x >> 31);
 	unsigned int mantissa;
 	unsigned int exp;
 	GLhalf		 hf;

 	/* get mantissa */
 	mantissa = x & ((1 << 23) - 1);
 	/* get exponent bits */
 	exp = x & FLOAT_MAX_BIASED_EXP;
 	if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* check if the original single precision float number is a NaN */
 		if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
 		{
 			/* we have a single precision NaN */
 			mantissa = (1 << 23) - 1;
 		}
 		else
 		{
 			/* 16-bit half-float representation stores number as Inf */
 			mantissa = 0;
 		}
 		hf = (((GLhalf)sign) << 15) | (GLhalf)(HALF_FLOAT_MAX_BIASED_EXP) | (GLhalf)(mantissa >> 13);
 	}
 	/* check if exponent is <= -15 */
 	else if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* store a denorm half-float value or zero */
 		exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
 		mantissa |= (1 << 23);
 		mantissa >>= (14 + exp);
 		hf = (((GLhalf)sign) << 15) | (GLhalf)(mantissa);
 	}
 	else
 	{
 		hf = (((GLhalf)sign) << 15) | (GLhalf)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) |
 			 (GLhalf)(mantissa >> 13);
 	}

 	return hf;
 }

 /* -15 stored using a single precision bias of 127 */
 const unsigned int FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
 /* max exponent value in single precision that will be converted */
 /* to Inf or Nan when stored as a half-float */
 const unsigned int FLOAT11_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
 const unsigned int FLOAT11_MAX_BIASED_EXP				   = (0x1F << 6);

 GLuint floatToUnisgnedF11(float f)
 {
 	union {
 		float		 v;
 		unsigned int x;
 	};
 	v				  = f;
 	unsigned int sign = (GLhalf)(x >> 31);
 	unsigned int mantissa;
 	unsigned int exp;
 	GLuint		 f11;

 	/* get mantissa */
 	mantissa = x & ((1 << 23) - 1);
 	/* get exponent bits */
 	exp = x & FLOAT_MAX_BIASED_EXP;

 	/* minus f32 value */
 	if (sign > 0)
 	{
 		/* f32 NaN -> f11 NaN */
 		if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
 		{
 			f11 = (GLuint)(FLOAT11_MAX_BIASED_EXP) | (GLuint)(0x0000003F);
 		}
 		/* Others round to 0.0 */
 		else
 		{
 			f11 = 0x00000000;
 		}

 		return f11;
 	}

 	/* only check positive value below */
 	if (exp >= FLOAT11_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* check if the original single precision float number is a NaN */
 		if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
 		{
 			/* we have a single precision NaN */
 			mantissa = (1 << 23) - 1;
 		}
 		else
 		{
 			/* 11-bit float representation stores number as Inf */
 			mantissa = 0;
 		}
 		f11 = (GLuint)(FLOAT11_MAX_BIASED_EXP) | (GLuint)(mantissa >> 17);
 	}
 	/* check if exponent is <= -15 */
 	else if (exp <= FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* store a denorm 11-bit float value or zero */
 		exp = (FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
 		mantissa |= (1 << 23);
 		if (18 + exp >= sizeof(mantissa) * 8)
 		{
 			mantissa = 0;
 		}
 		else
 		{
 			mantissa >>= (18 + exp);
 		}
 		f11 = mantissa;
 	}
 	else
 	{
 		f11 = ((exp - FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 17) | (mantissa >> 17);
 	}

 	return f11;
 }

 /* -15 stored using a single precision bias of 127 */
 const unsigned int FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
 /* max exponent value in single precision that will be converted */
 /* to Inf or Nan when stored as a half-float */
 const unsigned int FLOAT10_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
 const unsigned int FLOAT10_MAX_BIASED_EXP				   = (0x1F << 5);

 GLuint floatToUnisgnedF10(float f)
 {
 	union {
 		float		 v;
 		unsigned int x;
 	};
 	v				  = f;
 	unsigned int sign = (GLhalf)(x >> 31);
 	unsigned int mantissa;
 	unsigned int exp;
 	GLuint		 f10;

 	/* get mantissa */
 	mantissa = x & ((1 << 23) - 1);
 	/* get exponent bits */
 	exp = x & FLOAT_MAX_BIASED_EXP;

 	/* minus f32 value */
 	if (sign > 0)
 	{
 		/* f32 NaN -> f10 NaN */
 		if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
 		{
 			f10 = (GLuint)(FLOAT10_MAX_BIASED_EXP) | (GLuint)(0x0000001F);
 		}
 		/* Others round to 0.0 */
 		else
 		{
 			f10 = 0x00000000;
 		}

 		return f10;
 	}

 	/* only check positive value below */
 	if (exp >= FLOAT10_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* check if the original single precision float number is a NaN */
 		if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
 		{
 			/* we have a single precision NaN */
 			mantissa = (1 << 23) - 1;
 		}
 		else
 		{
 			/* 10-bit float representation stores number as Inf */
 			mantissa = 0;
 		}
 		f10 = (GLuint)(FLOAT10_MAX_BIASED_EXP) | (GLuint)(mantissa >> 18);
 	}
 	/* check if exponent is <= -15 */
 	else if (exp <= FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
 	{
 		/* store a denorm 11-bit float value or zero */
 		exp = (FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
 		mantissa |= (1 << 23);
 		if (19 + exp >= sizeof(mantissa) * 8)
 		{
 			mantissa = 0;
 		}
 		else
 		{
 			mantissa >>= (19 + exp);
 		}
 		f10 = mantissa;
 	}
 	else
 	{
 		f10 = ((exp - FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 18) | (mantissa >> 18);
 	}

 	return f10;
 }

 float halfFloatToFloat(GLhalf hf)
 {
 	unsigned int sign	 = (unsigned int)(hf >> 15);
 	unsigned int mantissa = (unsigned int)(hf & ((1 << 10) - 1));
 	unsigned int exp	  = (unsigned int)(hf & HALF_FLOAT_MAX_BIASED_EXP);
 	union {
 		float		 f;
 		unsigned int ui;
 	};

 	if (exp == HALF_FLOAT_MAX_BIASED_EXP)
 	{
 		/* we have a half-float NaN or Inf */
 		/* half-float NaNs will be converted to a single precision NaN */
 		/* half-float Infs will be converted to a single precision Inf */
 		exp = FLOAT_MAX_BIASED_EXP;
 		if (mantissa)
 			mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
 	}
 	else if (exp == 0x0)
 	{
 		/* convert half-float zero/denorm to single precision value */
 		if (mantissa)
 		{
 			mantissa <<= 1;
 			exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 			/* check for leading 1 in denorm mantissa */
 			while ((mantissa & (1 << 10)) == 0)
 			{
 				/* for every leading 0, decrement single precision exponent by 1 */
 				/* and shift half-float mantissa value to the left */
 				mantissa <<= 1;
 				exp -= (1 << 23);
 			}
 			/* clamp the mantissa to 10-bits */
 			mantissa &= ((1 << 10) - 1);
 			/* shift left to generate single-precision mantissa of 23-bits */
 			mantissa <<= 13;
 		}
 	}
 	else
 	{
 		/* shift left to generate single-precision mantissa of 23-bits */
 		mantissa <<= 13;
 		/* generate single precision biased exponent value */
 		exp = (exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 	}
 	ui = (sign << 31) | exp | mantissa;
 	return f;
 }

 float unsignedF11ToFloat(GLuint f11)
 {
 	unsigned int mantissa = (unsigned int)(f11 & ((1 << 6) - 1));
 	unsigned int exp	  = (unsigned int)(f11 & FLOAT11_MAX_BIASED_EXP);
 	union {
 		float		 f;
 		unsigned int ui;
 	};

 	if (exp == FLOAT11_MAX_BIASED_EXP)
 	{
 		/* we have a f11 NaN or Inf */
 		/* f11 NaNs will be converted to a single precision NaN */
 		/* f11 Infs will be converted to a single precision Inf */
 		exp = FLOAT_MAX_BIASED_EXP;
 		if (mantissa)
 			mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
 	}
 	else if (exp == 0x0)
 	{
 		/* convert f11 zero/denorm to single precision value */
 		if (mantissa)
 		{
 			mantissa <<= 1;
 			exp = FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 			/* check for leading 1 in denorm mantissa */
 			while ((mantissa & (1 << 10)) == 0)
 			{
 				/* for every leading 0, decrement single precision exponent by 1 */
 				/* and shift half-float mantissa value to the left */
 				mantissa <<= 1;
 				exp -= (1 << 23);
 			}
 			/* clamp the mantissa to 6-bits */
 			mantissa &= ((1 << 6) - 1);
 			/* shift left to generate single-precision mantissa of 23-bits */
 			mantissa <<= 17;
 		}
 	}
 	else
 	{
 		/* shift left to generate single-precision mantissa of 23-bits */
 		mantissa <<= 17;
 		/* generate single precision biased exponent value */
 		exp = (exp << 17) + FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 	}
 	ui = exp | mantissa;
 	return f;
 }

 float unsignedF10ToFloat(GLuint f10)
 {
 	unsigned int mantissa = (unsigned int)(f10 & ((1 << 5) - 1));
 	unsigned int exp	  = (unsigned int)(f10 & FLOAT10_MAX_BIASED_EXP);
 	union {
 		float		 f;
 		unsigned int ui;
 	};

 	if (exp == FLOAT10_MAX_BIASED_EXP)
 	{
 		/* we have a f11 NaN or Inf */
 		/* f11 NaNs will be converted to a single precision NaN */
 		/* f11 Infs will be converted to a single precision Inf */
 		exp = FLOAT_MAX_BIASED_EXP;
 		if (mantissa)
 			mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
 	}
 	else if (exp == 0x0)
 	{
 		/* convert f11 zero/denorm to single precision value */
 		if (mantissa)
 		{
 			mantissa <<= 1;
 			exp = FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 			/* check for leading 1 in denorm mantissa */
 			while ((mantissa & (1 << 10)) == 0)
 			{
 				/* for every leading 0, decrement single precision exponent by 1 */
 				/* and shift half-float mantissa value to the left */
 				mantissa <<= 1;
 				exp -= (1 << 23);
 			}
 			/* clamp the mantissa to 5-bits */
 			mantissa &= ((1 << 5) - 1);
 			/* shift left to generate single-precision mantissa of 23-bits */
 			mantissa <<= 18;
 		}
 	}
 	else
 	{
 		/* shift left to generate single-precision mantissa of 23-bits */
 		mantissa <<= 18;
 		/* generate single precision biased exponent value */
 		exp = (exp << 18) + FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
 	}
 	ui = exp | mantissa;
 	return f;
 }

 } // glcts
	/*-------------------------------------------------------------------------
	* OpenGL Conformance Test Suite
	* -----------------------------
	*
	* Copyright (c) 2017 The Khronos Group Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	/ /!
	* \file glcMisc.cpp
	* \brief Miscellaneous helper functions.
	/ /-------------------------------------------------------------------*/

	#include "glcMisc.hpp"

	using namespace glw;

	namespace glcts
	{

	/* utility functions from the book OpenGL ES 2.0 Programming Guide */
	/* -15 stored using a single precision bias of 127 */
	const unsigned int HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
	/* max exponent value in single precision that will be converted */
	/* to Inf or Nan when stored as a half-float */
	const unsigned int HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
	/* 255 is the max exponent biased value */
	const unsigned int FLOAT_MAX_BIASED_EXP = (0xFF << 23);
	const unsigned int HALF_FLOAT_MAX_BIASED_EXP = (0x1F << 10);

	GLhalf floatToHalfFloat(float f)
	{
	union {
	float v;
	unsigned int x;
	};
	v = f;
	unsigned int sign = (GLhalf)(x >> 31);
	unsigned int mantissa;
	unsigned int exp;
	GLhalf hf;

	/* get mantissa */
	mantissa = x & ((1 << 23) - 1);
	/* get exponent bits */
	exp = x & FLOAT_MAX_BIASED_EXP;
	if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* check if the original single precision float number is a NaN */
	if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
	{
	/* we have a single precision NaN */
	mantissa = (1 << 23) - 1;
	}
	else
	{
	/* 16-bit half-float representation stores number as Inf */
	mantissa = 0;
	}
	hf = (((GLhalf)sign) << 15) \| (GLhalf)(HALF_FLOAT_MAX_BIASED_EXP) \| (GLhalf)(mantissa >> 13);
	}
	/* check if exponent is <= -15 */
	else if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* store a denorm half-float value or zero */
	exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
	mantissa \|= (1 << 23);
	mantissa >>= (14 + exp);
	hf = (((GLhalf)sign) << 15) \| (GLhalf)(mantissa);
	}
	else
	{
	hf = (((GLhalf)sign) << 15) \| (GLhalf)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) \|
	(GLhalf)(mantissa >> 13);
	}

	return hf;
	}

	/* -15 stored using a single precision bias of 127 */
	const unsigned int FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
	/* max exponent value in single precision that will be converted */
	/* to Inf or Nan when stored as a half-float */
	const unsigned int FLOAT11_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
	const unsigned int FLOAT11_MAX_BIASED_EXP = (0x1F << 6);

	GLuint floatToUnisgnedF11(float f)
	{
	union {
	float v;
	unsigned int x;
	};
	v = f;
	unsigned int sign = (GLhalf)(x >> 31);
	unsigned int mantissa;
	unsigned int exp;
	GLuint f11;

	/* get mantissa */
	mantissa = x & ((1 << 23) - 1);
	/* get exponent bits */
	exp = x & FLOAT_MAX_BIASED_EXP;

	/* minus f32 value */
	if (sign > 0)
	{
	/* f32 NaN -> f11 NaN */
	if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
	{
	f11 = (GLuint)(FLOAT11_MAX_BIASED_EXP) \| (GLuint)(0x0000003F);
	}
	/* Others round to 0.0 */
	else
	{
	f11 = 0x00000000;
	}

	return f11;
	}

	/* only check positive value below */
	if (exp >= FLOAT11_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* check if the original single precision float number is a NaN */
	if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
	{
	/* we have a single precision NaN */
	mantissa = (1 << 23) - 1;
	}
	else
	{
	/* 11-bit float representation stores number as Inf */
	mantissa = 0;
	}
	f11 = (GLuint)(FLOAT11_MAX_BIASED_EXP) \| (GLuint)(mantissa >> 17);
	}
	/* check if exponent is <= -15 */
	else if (exp <= FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* store a denorm 11-bit float value or zero */
	exp = (FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
	mantissa \|= (1 << 23);
	if (18 + exp >= sizeof(mantissa) * 8)
	{
	mantissa = 0;
	}
	else
	{
	mantissa >>= (18 + exp);
	}
	f11 = mantissa;
	}
	else
	{
	f11 = ((exp - FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 17) \| (mantissa >> 17);
	}

	return f11;
	}

	/* -15 stored using a single precision bias of 127 */
	const unsigned int FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP = 0x38000000;
	/* max exponent value in single precision that will be converted */
	/* to Inf or Nan when stored as a half-float */
	const unsigned int FLOAT10_MAX_BIASED_EXP_AS_SINGLE_FP_EXP = 0x47800000;
	const unsigned int FLOAT10_MAX_BIASED_EXP = (0x1F << 5);

	GLuint floatToUnisgnedF10(float f)
	{
	union {
	float v;
	unsigned int x;
	};
	v = f;
	unsigned int sign = (GLhalf)(x >> 31);
	unsigned int mantissa;
	unsigned int exp;
	GLuint f10;

	/* get mantissa */
	mantissa = x & ((1 << 23) - 1);
	/* get exponent bits */
	exp = x & FLOAT_MAX_BIASED_EXP;

	/* minus f32 value */
	if (sign > 0)
	{
	/* f32 NaN -> f10 NaN */
	if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
	{
	f10 = (GLuint)(FLOAT10_MAX_BIASED_EXP) \| (GLuint)(0x0000001F);
	}
	/* Others round to 0.0 */
	else
	{
	f10 = 0x00000000;
	}

	return f10;
	}

	/* only check positive value below */
	if (exp >= FLOAT10_MAX_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* check if the original single precision float number is a NaN */
	if (mantissa && (exp == FLOAT_MAX_BIASED_EXP))
	{
	/* we have a single precision NaN */
	mantissa = (1 << 23) - 1;
	}
	else
	{
	/* 10-bit float representation stores number as Inf */
	mantissa = 0;
	}
	f10 = (GLuint)(FLOAT10_MAX_BIASED_EXP) \| (GLuint)(mantissa >> 18);
	}
	/* check if exponent is <= -15 */
	else if (exp <= FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP)
	{
	/* store a denorm 11-bit float value or zero */
	exp = (FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23;
	mantissa \|= (1 << 23);
	if (19 + exp >= sizeof(mantissa) * 8)
	{
	mantissa = 0;
	}
	else
	{
	mantissa >>= (19 + exp);
	}
	f10 = mantissa;
	}
	else
	{
	f10 = ((exp - FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 18) \| (mantissa >> 18);
	}

	return f10;
	}

	float halfFloatToFloat(GLhalf hf)
	{
	unsigned int sign = (unsigned int)(hf >> 15);
	unsigned int mantissa = (unsigned int)(hf & ((1 << 10) - 1));
	unsigned int exp = (unsigned int)(hf & HALF_FLOAT_MAX_BIASED_EXP);
	union {
	float f;
	unsigned int ui;
	};

	if (exp == HALF_FLOAT_MAX_BIASED_EXP)
	{
	/* we have a half-float NaN or Inf */
	/* half-float NaNs will be converted to a single precision NaN */
	/* half-float Infs will be converted to a single precision Inf */
	exp = FLOAT_MAX_BIASED_EXP;
	if (mantissa)
	mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
	}
	else if (exp == 0x0)
	{
	/* convert half-float zero/denorm to single precision value */
	if (mantissa)
	{
	mantissa <<= 1;
	exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	/* check for leading 1 in denorm mantissa */
	while ((mantissa & (1 << 10)) == 0)
	{
	/* for every leading 0, decrement single precision exponent by 1 */
	/* and shift half-float mantissa value to the left */
	mantissa <<= 1;
	exp -= (1 << 23);
	}
	/* clamp the mantissa to 10-bits */
	mantissa &= ((1 << 10) - 1);
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 13;
	}
	}
	else
	{
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 13;
	/* generate single precision biased exponent value */
	exp = (exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	}
	ui = (sign << 31) \| exp \| mantissa;
	return f;
	}

	float unsignedF11ToFloat(GLuint f11)
	{
	unsigned int mantissa = (unsigned int)(f11 & ((1 << 6) - 1));
	unsigned int exp = (unsigned int)(f11 & FLOAT11_MAX_BIASED_EXP);
	union {
	float f;
	unsigned int ui;
	};

	if (exp == FLOAT11_MAX_BIASED_EXP)
	{
	/* we have a f11 NaN or Inf */
	/* f11 NaNs will be converted to a single precision NaN */
	/* f11 Infs will be converted to a single precision Inf */
	exp = FLOAT_MAX_BIASED_EXP;
	if (mantissa)
	mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
	}
	else if (exp == 0x0)
	{
	/* convert f11 zero/denorm to single precision value */
	if (mantissa)
	{
	mantissa <<= 1;
	exp = FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	/* check for leading 1 in denorm mantissa */
	while ((mantissa & (1 << 10)) == 0)
	{
	/* for every leading 0, decrement single precision exponent by 1 */
	/* and shift half-float mantissa value to the left */
	mantissa <<= 1;
	exp -= (1 << 23);
	}
	/* clamp the mantissa to 6-bits */
	mantissa &= ((1 << 6) - 1);
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 17;
	}
	}
	else
	{
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 17;
	/* generate single precision biased exponent value */
	exp = (exp << 17) + FLOAT11_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	}
	ui = exp \| mantissa;
	return f;
	}

	float unsignedF10ToFloat(GLuint f10)
	{
	unsigned int mantissa = (unsigned int)(f10 & ((1 << 5) - 1));
	unsigned int exp = (unsigned int)(f10 & FLOAT10_MAX_BIASED_EXP);
	union {
	float f;
	unsigned int ui;
	};

	if (exp == FLOAT10_MAX_BIASED_EXP)
	{
	/* we have a f11 NaN or Inf */
	/* f11 NaNs will be converted to a single precision NaN */
	/* f11 Infs will be converted to a single precision Inf */
	exp = FLOAT_MAX_BIASED_EXP;
	if (mantissa)
	mantissa = (1 << 23) - 1; /* set all bits to indicate a NaN */
	}
	else if (exp == 0x0)
	{
	/* convert f11 zero/denorm to single precision value */
	if (mantissa)
	{
	mantissa <<= 1;
	exp = FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	/* check for leading 1 in denorm mantissa */
	while ((mantissa & (1 << 10)) == 0)
	{
	/* for every leading 0, decrement single precision exponent by 1 */
	/* and shift half-float mantissa value to the left */
	mantissa <<= 1;
	exp -= (1 << 23);
	}
	/* clamp the mantissa to 5-bits */
	mantissa &= ((1 << 5) - 1);
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 18;
	}
	}
	else
	{
	/* shift left to generate single-precision mantissa of 23-bits */
	mantissa <<= 18;
	/* generate single precision biased exponent value */
	exp = (exp << 18) + FLOAT10_MIN_BIASED_EXP_AS_SINGLE_FP_EXP;
	}
	ui = exp \| mantissa;
	return f;
	}

	} // glcts