"
 COPYRIGHT (c) 2014 by Claus Gittinger
              All Rights Reserved

 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 other person.  No title to or ownership of the software is
 hereby transferred.
"
"{ Package: 'stx:libbasic2' }"

"{ NameSpace: Smalltalk }"

UnboxedFloatArray variableWordSubclass:#HalfFloatArray
	instanceVariableNames:''
	classVariableNames:''
	poolDictionaries:''
	category:'Collections-Arrayed'
!

!HalfFloatArray primitiveFunctions!
%{
typedef unsigned short halffloat;
typedef unsigned short uint16;
typedef unsigned int   uint32;
#if 0
#if defined(__GNUC__) || defined(__CLANG__) || defined(__MINGW__)
inline float 
XMConvertHalfToFloat(HALF Value) {
    __m128i V1 = _mm_cvtsi32_si128( static_cast<uint32_t>(Value) );
    __m128 V2 = _mm_cvtph_ps( V1 );
    return _mm_cvtss_f32( V2 );
}

inline HALF 
XMConvertFloatToHalf(float Value) {
    __m128 V1 = _mm_set_ss( Value );
    __m128i V2 = _mm_cvtps_ph( V1, 0 );
    return static_cast<HALF>( _mm_cvtsi128_si32(V2) );
}
#endif
#endif
//
// convert a halffloat (16-bit float) to a float
//
float
__STX_halffloat_to_float(halffloat h) {
        int e;
        uint16 hs, he, hm;
        uint32 xs, xe, xm;
        int32 xes;
        union {
            uint32 u32;
            float f32;
        } u;

        if( (h & 0x7FFFu) == 0 ) {  // Signed zero
            u.u32 = ((uint32) h) << 16;  // Return the signed zero
        } else { // Not zero
            hs = h & 0x8000u;  // Pick off sign bit
            he = h & 0x7C00u;  // Pick off exponent bits
            hm = h & 0x03FFu;  // Pick off mantissa bits
            if( he == 0 ) {  // Denormal will convert to normalized
                e = -1; // The following loop figures out how much extra to adjust the exponent
                do {
                    e++;
                    hm <<= 1;
                } while( (hm & 0x0400u) == 0 ); // Shift until leading bit overflows into exponent bit
                xs = ((uint32) hs) << 16; // Sign bit
                xes = ((uint32) (he >> 10)) - 15 + 127 - e; // Exponent unbias the halfp, then bias the single
                xe = (uint32) (xes << 23); // Exponent
                xm = ((uint32) (hm & 0x03FFu)) << 13; // Mantissa
                u.u32 = (xs | xe | xm); // Combine sign bit, exponent bits, and mantissa bits
            } else if( he == 0x7C00u ) {  // Inf or NaN (all the exponent bits are set)
                if( hm == 0 ) { // If mantissa is zero ...
                    u.u32 = (((uint32) hs) << 16) | ((uint32) 0x7F800000u); // Signed Inf
                } else {
                    u.u32 = (uint32) 0xFFC00000u; // NaN, only 1st mantissa bit set
                }
            } else { // Normalized number
                xs = ((uint32) hs) << 16; // Sign bit
                xes = ((uint32) (he >> 10)) - 15 + 127; // Exponent unbias the halfp, then bias the single
                xe = (uint32) (xes << 23); // Exponent
                xm = ((uint32) hm) << 13; // Mantissa
                u.u32 = (xs | xe | xm); // Combine sign bit, exponent bits, and mantissa bits
            }
        }
        return u.f32;
}

//
// convert a float to a halffloat (16-bit float)
//
halffloat
__STX_float_to_halffloat(float f32) {
        uint16    hs, he, hm;
        uint32 x, xs, xe, xm;
        int hes;
        union {
            uint32 u32;
            float f32;
        } u;
        halffloat h;

        u.f32 = f32;
        x = u.u32;
        if( (x & 0x7FFFFFFFu) == 0 ) {  // Signed zero
            h = (uint16) (x >> 16);  // Return the signed zero
        } else { // Not zero
            xs = x & 0x80000000u;  // Pick off sign bit
            xe = x & 0x7F800000u;  // Pick off exponent bits
            xm = x & 0x007FFFFFu;  // Pick off mantissa bits
            if( xe == 0 ) {  // Denormal will underflow, return a signed zero
                h = (uint16) (xs >> 16);
            } else if( xe == 0x7F800000u ) {  // Inf or NaN (all the exponent bits are set)
                if( xm == 0 ) { // If mantissa is zero ...
                    h = (uint16) ((xs >> 16) | 0x7C00u); // Signed Inf
                } else {
                    h = (uint16) 0xFE00u; // NaN, only 1st mantissa bit set
                }
            } else { // Normalized number
                hs = (uint16) (xs >> 16); // Sign bit
                hes = ((int)(xe >> 23)) - 127 + 15; // Exponent unbias the single, then bias the halfp
                if( hes >= 0x1F ) {  // Overflow
                    h = (uint16) ((xs >> 16) | 0x7C00u); // Signed Inf
                } else if( hes <= 0 ) {  // Underflow
                    if( (14 - hes) > 24 ) {  // Mantissa shifted all the way off & no rounding possibility
                        hm = (uint16) 0u;  // Set mantissa to zero
                    } else {
                        xm |= 0x00800000u;  // Add the hidden leading bit
                        hm = (uint16) (xm >> (14 - hes)); // Mantissa
                        if( (xm >> (13 - hes)) & 0x00000001u ) // Check for rounding
                            hm += (uint16) 1u; // Round, might overflow into exp bit, but this is OK
                    }
                    h = (hs | hm); // Combine sign bit and mantissa bits, biased exponent is zero
                } else {
                    he = (uint16) (hes << 10); // Exponent
                    hm = (uint16) (xm >> 13); // Mantissa
                    if( xm & 0x00001000u ) // Check for rounding
                        h = (hs | he | hm) + (uint16) 1u; // Round, might overflow to inf, this is OK
                    else
                        h = (hs | he | hm);  // No rounding
                }
            }
        }
        return h;
}

%}
! !

!HalfFloatArray class methodsFor:'documentation'!

copyright
"
 COPYRIGHT (c) 2014 by Claus Gittinger
              All Rights Reserved

 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 other person.  No title to or ownership of the software is
 hereby transferred.
"
!

documentation
"
    HalfFloatArrays store half precision (16bit) floats (and nothing else).
    HalfFloats were traditionally seldom used, but seem to become more popular
    these days, as some 3D graphics accelerators and game engines use them
    for very dense and compact storage of texture and vertex data.

    Notice, that HalfFloats are not supported as first class objects by the ST/X system;
    i.e. outside of a HalfFloatArray, these values are represented as floats
    or doubles. When accessing a HalfFloatArray's element via getters/setters,
    shortFloat (i.e. single precision 32bit floats) are exchanged.

    Be aware that the numeric range of a half-float is very very limited.

    [memory requirements:]
        OBJ-HEADER + (size * 2)

    [See also:]
        FloatArray DoubleArray Array
        http://www.opengl.org/wiki/Small_Float_Formats

    [author:]
        Claus Gittinger
"
! !

!HalfFloatArray class methodsFor:'queries'!

elementByteSize
    "for bit-like containers, return the number of bytes stored per element.
     Here, 2 is returned"

    ^ 2
! !

!HalfFloatArray methodsFor:'accessing'!

at:index
%{  /* NOCONTEXT */
    if (__isSmallInteger(index)) {
	int i = __intVal(index);
	int n = __wordArraySize(self);

	if ((unsigned)i <= n) {
	    unsigned short h;
	    OBJ newFloat;
	    float f;

	    h = __WordArrayInstPtr(self)->s_element[i-1];

	    f = __STX_halffloat_to_float(h);
	    __qMKSFLOAT(newFloat, f);
	    RETURN ( newFloat );
	}
    }
%}.
    self primitiveFailed
!

at:index put:aFloat
%{
    if (__isSmallInteger(index)) {
	int i = __intVal(index);
	int n = __wordArraySize(self);

	if ((unsigned)i <= n) {
	    unsigned short h;
	    float f;

	    if (__isFloat(aFloat)) {
		f = (float)(__floatVal(aFloat));
	    } else if (__isShortFloat(aFloat)) {
		f = __shortFloatVal(aFloat);
	    } else if (__isSmallInteger(aFloat)) {
		f = (float)(__intVal(aFloat));
	    } else
		goto error;

	    h = __STX_float_to_halffloat(f);
	    __WordArrayInstPtr(self)->s_element[i-1] = h;
	    RETURN (aFloat);
	}
    }
  error: ;
%}.
    self primitiveFailed
! !

!HalfFloatArray methodsFor:'queries'!

defaultElement
    ^ ShortFloat zero
!

isValidElement:anObject
    "return true, if I can hold this kind of object"

    ^ anObject isNumber
!

numFloats
    ^ self size
! !

!HalfFloatArray methodsFor:'testing'!

isFloatArray
    "return true if the receiver has float elements.
     These are Float, Double- and HalfFloat arrays"

    ^ true

    "Created: / 02-03-2019 / 23:14:00 / Claus Gittinger"
! !

!HalfFloatArray class methodsFor:'documentation'!

version
    ^ '$Header$'
!

version_CVS
    ^ '$Header$'
! !