1 /*---------------------------------------------------------------------------*
2   Project:  Horizon
3   File:     gd_Utils.h
4 
5   Copyright (C)2011 Nintendo Co., Ltd.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law. They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13  *---------------------------------------------------------------------------*/
14 #ifndef NN_GD_CTR_GD_UTILS_H_
15 #define NN_GD_CTR_GD_UTILS_H_
16 
17 #include <nn/gd/CTR/gd_Types.h>
18 
19 #if NN_GD_DOCUMENT_TYPE == ENGLISH
20 /* Please see man pages for details
21 
22 */
23 #else
24 /* Please see man pages for details
25 
26 */
27 #endif
28 
29 namespace nn {
30 namespace gd {
31 namespace CTR {
32 
33 #if NN_GD_DOCUMENT_TYPE == ENGLISH
34 /* Please see man pages for details
35 
36 
37 */
38 /*  */ // defgroup utilityFunction
39 #else
40 /* Please see man pages for details
41 
42 
43 */
44 /*  */ // defgroup utilityFunction
45 #endif
46 
47 #if NN_GD_DOCUMENT_TYPE == ENGLISH
48 /* Please see man pages for details
49 
50 
51 
52 
53 */
54 #else
55 /* Please see man pages for details
56 
57 
58 
59 
60 */
61 #endif
62 class Utils
63 {
64 public:
65     #if NN_GD_DOCUMENT_TYPE == ENGLISH
66     /* Please see man pages for details
67 
68 
69 
70 
71     */
72     #else
73     /* Please see man pages for details
74 
75 
76 
77 
78     */
79     #endif
80     static void ConvertStartEndToScaleBias(f32 start, f32 end, f32& scale, f32& bias);
81 
82     #if NN_GD_DOCUMENT_TYPE == ENGLISH
83     /* Please see man pages for details
84 
85 
86     */
87     #else
88     /* Please see man pages for details
89 
90 
91     */
92     #endif
93     static u8 FloatToUnsignedByte(f32 val);
94 
95     #if NN_GD_DOCUMENT_TYPE == ENGLISH
96     /* Please see man pages for details
97 
98 
99     */
100     #else
101     /* Please see man pages for details
102 
103 
104     */
105     #endif
106     static u8 FloatToUnsignedByteNoClamp(f32 val);
107 
108     #if NN_GD_DOCUMENT_TYPE == ENGLISH
109     /* Please see man pages for details
110 
111     */
112     #else
113     /* Please see man pages for details
114 
115     */
116     #endif
117     static s8 FloatToSignedByte(f32 val);
118 
119     #if NN_GD_DOCUMENT_TYPE == ENGLISH
120     /* Please see man pages for details
121 
122 
123     */
124     #else
125     /* Please see man pages for details
126 
127 
128     */
129     #endif
130     static u16 Float32ToFloat16( f32 val );
131 
132     #if NN_GD_DOCUMENT_TYPE == ENGLISH
133     /* Please see man pages for details
134 
135 
136     */
137     #else
138     /* Please see man pages for details
139 
140 
141     */
142     #endif
143     static u32 Float32ToFix13Fraction11( f32 val );
144 
145     #if NN_GD_DOCUMENT_TYPE == ENGLISH
146     /* Please see man pages for details
147 
148 
149     */
150     #else
151     /* Please see man pages for details
152 
153 
154     */
155     #endif
156     static u32 Float32ToUnsignedFix12( f32 val );
157 
158     #if NN_GD_DOCUMENT_TYPE == ENGLISH
159     /* Please see man pages for details
160 
161 
162     */
163     #else
164     /* Please see man pages for details
165 
166 
167     */
168     #endif
169     static u32 Float32ToFix12( f32 val );
170 
171     #if NN_GD_DOCUMENT_TYPE == ENGLISH
172     /* Please see man pages for details
173 
174 
175     */
176     #else
177     /* Please see man pages for details
178 
179 
180     */
181     #endif
182     static u32 Float32ToFix12Fraction11( f32 val );
183 
184     #if NN_GD_DOCUMENT_TYPE == ENGLISH
185     /* Please see man pages for details
186 
187 
188     */
189     #else
190     /* Please see man pages for details
191 
192 
193     */
194     #endif
195     static u32 Float32ToUnsignedFix11( f32 val );
196 
197     #if NN_GD_DOCUMENT_TYPE == ENGLISH
198     /* Please see man pages for details
199 
200 
201     */
202     #else
203     /* Please see man pages for details
204 
205 
206     */
207     #endif
208     static u8 Float32ToFix8Fraction7( f32 val );
209 
210     #if NN_GD_DOCUMENT_TYPE == ENGLISH
211     /* Please see man pages for details
212 
213 
214     */
215     #else
216     /* Please see man pages for details
217 
218 
219     */
220     #endif
221     static u16 Float32ToFix16( f32 val );
222 
223     #if NN_GD_DOCUMENT_TYPE == ENGLISH
224     /* Please see man pages for details
225 
226 
227     */
228     #else
229     /* Please see man pages for details
230 
231 
232     */
233     #endif
234     static u32 Float32ToFloat24( f32 val );
235 
236     #if NN_GD_DOCUMENT_TYPE == ENGLISH
237     /* Please see man pages for details
238 
239 
240     */
241     #else
242     /* Please see man pages for details
243 
244 
245     */
246     #endif
247     static u32 Float32ToFloat31( f32 val );
248 
249     #if NN_GD_DOCUMENT_TYPE == ENGLISH
250     /* Please see man pages for details
251 
252 
253     */
254     #else
255     /* Please see man pages for details
256 
257 
258     */
259     #endif
260     static u32 Float32ToFloat20( f32 val );
261 
262     #if NN_GD_DOCUMENT_TYPE == ENGLISH
263     /* Please see man pages for details
264 
265 
266     */
267     #else
268     /* Please see man pages for details
269 
270 
271     */
272     #endif
273     static u32 Float32ToFix13Fraction8( f32 val );
274 
275     #if NN_GD_DOCUMENT_TYPE == ENGLISH
276     /* Please see man pages for details
277 
278 
279     */
280     #else
281     /* Please see man pages for details
282 
283 
284     */
285     #endif
286     static u32 Float32ToUnsignedFix16( f32 val );
287 
288     #if NN_GD_DOCUMENT_TYPE == ENGLISH
289     /* Please see man pages for details
290 
291 
292     */
293     #else
294     /* Please see man pages for details
295 
296 
297     */
298     #endif
299     static u32 Float32ToUnsignedFix24( f32 val );
300 
301     #if NN_GD_DOCUMENT_TYPE == ENGLISH
302     /* Please see man pages for details
303 
304 
305     */
306     #else
307     /* Please see man pages for details
308 
309 
310     */
311     #endif
312     static u32 Float32ToUnsignedFix8Fraction0( f32 val );
313 
314     #if NN_GD_DOCUMENT_TYPE == ENGLISH
315     /* Please see man pages for details
316 
317 
318     */
319     #else
320     /* Please see man pages for details
321 
322 
323     */
324     #endif
325     static u32 Float32ToUnsignedFix24Fraction8( f32 val );
326 
327 };  // Utils
328 
329 
ConvertStartEndToScaleBias(f32 start,f32 end,f32 & scale,f32 & bias)330 NN_FORCE_INLINE void Utils::ConvertStartEndToScaleBias(f32 start, f32 end, f32& scale, f32& bias)
331 {
332     scale = 1.f / ( end - start );
333     bias = -start * scale;
334 }
335 
FloatToUnsignedByte(f32 val)336 NN_FORCE_INLINE u8 Utils::FloatToUnsignedByte(f32 val)
337 {
338     return ( u8 )( 0.5f + ( val < 0.f ? 0.f : ( 1.f < val ? 1.f : val ) )  * ( 0xff ) );
339 }
340 
FloatToUnsignedByteNoClamp(f32 val)341 NN_FORCE_INLINE u8 Utils::FloatToUnsignedByteNoClamp(f32 val)
342 {
343     return ( u8 )( 0.5f + val * 0xff );
344 }
345 
FloatToSignedByte(f32 val)346 NN_FORCE_INLINE s8 Utils::FloatToSignedByte(f32 val)
347 {
348     f32 u = 127.f * (val);
349     u = u < 0.f? -u: u;
350     return ( s8 )( ((u32)u & 0x7f) | (val < 0.f ? 0x80 : 0) );
351 }
352 
Float32ToFloat16(f32 val)353 NN_FORCE_INLINE u16 Utils::Float32ToFloat16( f32 val )
354 {
355     static const int bias_ = 128 - (1 << (5 - 1));
356 
357     u32 uval_ = *( reinterpret_cast<u32*>( &val ) );
358     int e_ = (uval_ & 0x7fffffff) ? (((uval_ >> 23) & 0xff) - bias_) : 0;
359     if (e_ >= 0)
360     {
361         return ( u16 )( ((uval_ & 0x7fffff) >> (23 - 10)) | (e_ << 10) | ((uval_ >> 31) << (10 + 5)) );
362     }
363     return ( u16 )((uval_ >> 31) << (10 + 5));
364 }
365 
Float32ToFix13Fraction11(f32 val)366 NN_FORCE_INLINE u32 Utils::Float32ToFix13Fraction11( f32 val )
367 {
368     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
369     if( val == 0.f || (v_ & 0x7f800000) == 0x7f800000 )
370         return 0;
371 
372     val += 0.5f * (1 << 2);
373     val *= 1 << (13 - 2);
374     if (val < 0)
375         val = 0;
376     else if (val >= (1 << 13))
377         val = (1 << 13) - 1;
378 
379     return (val >= (1 << (13 - 1))) ? (unsigned)(val - (1 << (13 - 1))) : (unsigned)(val + (1 << (13 - 1)));
380 }
381 
Float32ToUnsignedFix12(f32 val)382 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix12( f32 val )
383 {
384     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
385     if( val <= 0 || (v_ & 0x7f800000) == 0x7f800000 )
386     {
387         return 0;
388     }
389     else
390     {
391         unsigned uval_;
392 
393         val *= 1 << (12 - 0);
394         if (val >= (1 << 12))
395         {
396             uval_ = (1 << 12) - 1;
397         }
398         else
399         {
400             uval_ = (unsigned)(val);
401         }
402 
403         return uval_;
404     }
405 }
406 
Float32ToFix12(f32 val)407 NN_FORCE_INLINE u32 Utils::Float32ToFix12( f32 val )
408 {
409     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
410     if( val == 0.f || (v_ & 0x7f800000) == 0x7f800000 )
411         return 0;
412 
413     int ret;
414 
415     val *= (1 << (12 - 1));
416 
417     if( val < 0 )
418     {
419         ret = 1 << (12 - 1);
420         val = -val;
421     }
422     else
423         ret = 0;
424 
425     if( val >= (1 << (12 - 1)) )
426         val  = (1 << (12 - 1)) - 1;
427 
428     ret |= (unsigned)(val);
429     return ret;
430 }
431 
Float32ToFix12Fraction11(f32 val)432 NN_FORCE_INLINE u32 Utils::Float32ToFix12Fraction11( f32 val )
433 {
434     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
435 
436     if (val == 0.f || (v_ & 0x7f800000) == 0x7f800000)
437     {
438         return 0;
439     }
440     else
441     {
442         val += 0.5f * (1 << 1);
443         val *= 1 << (12 - 1);
444 
445         if (val < 0)
446         {
447             val = 0;
448         }
449         else if (val >= (1 << 12))
450         {
451             val = (1 << 12) - 1;
452         }
453 
454         if (val >= (1 << (12 - 1)))
455         {
456             return (unsigned)(val - (1 << (12 - 1)));
457         }
458         else
459         {
460             return (unsigned)(val + (1 << (12 - 1)));
461         }
462     }
463 }
464 
Float32ToUnsignedFix11(f32 val)465 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix11( f32 val )
466 {
467     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
468     if( val <= 0 || (v_ & 0x7f800000) == 0x7f800000 )
469         return 0;
470 
471     unsigned uval_;
472 
473     val *= 1 << (11 - 0);
474     if (val >= (1 << 11))
475         uval_ = (1 << 11) - 1;
476     else
477         uval_ = (unsigned)(val);
478 
479     return uval_;
480 }
481 
Float32ToFix8Fraction7(f32 val)482 NN_FORCE_INLINE u8 Utils::Float32ToFix8Fraction7( f32 val )
483 {
484     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
485 
486     if (val == 0.f || (v_ & 0x7f800000) == 0x7f800000)
487     {
488         return 0;
489     }
490     else
491     {
492         val += 0.5f * (1 << 1);
493         val *= 1 << (8 - 1);
494 
495         if (val < 0)
496         {
497             val = 0;
498         }
499         else if (val >= (1 << 8))
500         {
501             val = (1 << 8) - 1;
502         }
503 
504         if (val >= (1 << (8 - 1)))
505         {
506             return (unsigned)(val - (1 << (8 - 1)));
507         }
508         else
509         {
510             return (unsigned)(val + (1 << (8 - 1)));
511         }
512     }
513 }
514 
Float32ToFix16(f32 val)515 NN_FORCE_INLINE u16 Utils::Float32ToFix16( f32 val )
516 {
517     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
518 
519     if ( (val == 0.f) || ( (v_ & 0x7f800000) == 0x7f800000 ) )
520     {
521         return 0;
522     }
523     else
524     {
525         val += 0.5f * (1 << 4);
526         val *= 1 << (16 - 4);
527         if (val < 0)
528         {
529             val = 0;
530         }
531         else if (val >= (1 << 16))
532         {
533             val = (1 << 16) - 1;
534         }
535 
536         if (val >= (1 << (16 - 1)))
537         {
538             return (unsigned)(val - (1 << (16 - 1)));
539         }
540         else
541         {
542             return (unsigned)(val + (1 << (16 - 1)));
543         }
544     }
545 }
546 
Float32ToFloat24(f32 val)547 NN_FORCE_INLINE u32 Utils::Float32ToFloat24( f32 val )
548 {
549     static const int bias_ = 128 - (1 << (7 - 1));
550     u32 uval_   = *( reinterpret_cast<unsigned*>( &val ) );
551     s32 e_      = (uval_ & 0x7fffffff) ? (((uval_ >> 23) & 0xff) - bias_) : 0;
552 
553     return e_ >= 0 ? ((uval_ & 0x7fffff) >> (23 - 16)) | (e_ << 16) | ((uval_ >> 31) << (16 + 7)) : ((uval_ >> 31) << (16 + 7));
554 }
555 
Float32ToFloat31(f32 val)556 NN_FORCE_INLINE u32 Utils::Float32ToFloat31( f32 val )
557 {
558     unsigned uval_, m_;
559     int e_;
560     float f_ = val;
561     static const int bias_ = 128 - (1 << (7 - 1));
562     uval_ = *( reinterpret_cast<unsigned*>( &f_ ) );
563     e_ = (uval_ & 0x7fffffff) ? (((uval_ >> 23) & 0xff) - bias_) : 0;
564     m_ = (uval_ & 0x7fffff) >> (23 - 23);
565     return e_ >= 0 ? m_ | (e_ << 23) | ((uval_ >> 31) << (23 + 7)) : ((uval_ >> 31) << (23 + 7));
566 }
567 
Float32ToFloat20(f32 val)568 NN_FORCE_INLINE u32 Utils::Float32ToFloat20( f32 val )
569 {
570     static const int bias_ = 128 - (1 << (7 - 1));
571     u32 uval_   = *( reinterpret_cast<unsigned*>( &val ) );
572     s32 e_      = (uval_ & 0x7fffffff) ? (((uval_ >> 23) & 0xff) - bias_) : 0;
573 
574     return e_ >= 0 ? ((uval_ & 0x7fffff) >> (23 - 12)) | (e_ << 12) | ((uval_ >> 31) << (12 + 7)) : ((uval_ >> 31) << (12 + 7));
575 }
576 
Float32ToFix13Fraction8(f32 val)577 NN_FORCE_INLINE u32 Utils::Float32ToFix13Fraction8( f32 val )
578 {
579     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
580     if ( ( val == 0.0f ) ||
581         ( (v_ & 0x7f800000) == 0x7f800000 ) )
582     {
583         return 0;
584     }
585 
586     val += 0.5f * (1 << 5);
587     val *= 1 << (13 - 5);
588     if (val < 0)
589     {
590         val = 0;
591     }
592     else if (val >= (1 << 13))
593     {
594         val = (1 << 13) - 1;
595     }
596 
597     return (val >= (1 << (13 - 1))) ? (unsigned)(val - (1 << (13 - 1))) : (unsigned)(val + (1 << (13 - 1)));
598 }
599 
Float32ToUnsignedFix16(f32 val)600 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix16( f32 val )
601 {
602     unsigned v_ = *( reinterpret_cast<unsigned*>( &val) );
603 
604     if (val <= 0 || (v_ & 0x7f800000) == 0x7f800000)
605     {
606         return 0;
607     }
608     else
609     {
610         val *= 1 << (16 - 0);
611         if ( val >= (1 << 16) )
612         {
613             return (1 << 16) - 1;
614         }
615         else
616         {
617             return (unsigned)( val );
618         }
619     }
620 }
621 
Float32ToUnsignedFix24(f32 val)622 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix24( f32 val )
623 {
624     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
625 
626     if (val <= 0 || (v_ & 0x7f800000) == 0x7f800000)
627     {
628         return 0;
629     }
630     else
631     {
632         val *= 1 << (24 - 0);
633 
634         if ( val >= (1 << 24) )
635         {
636             return (1 << 24) - 1;
637         }
638         else
639         {
640             return (unsigned)(val);
641         }
642     }
643 }
644 
Float32ToUnsignedFix8Fraction0(f32 val)645 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix8Fraction0( f32 val )
646 {
647     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
648     if( val <= 0 || (v_ & 0x7f800000) == 0x7f800000 )
649     {
650         return 0;
651     }
652     else
653     {
654         unsigned uval_;
655 
656         val *= 1 << (8 - 8);
657         if (val >= (1 << 8))
658         {
659             uval_ = (1 << 8) - 1;
660         }
661         else
662         {
663             uval_ = (unsigned)(val);
664         }
665 
666         return uval_;
667     }
668 }
669 
Float32ToUnsignedFix24Fraction8(f32 val)670 NN_FORCE_INLINE u32 Utils::Float32ToUnsignedFix24Fraction8( f32 val )
671 {
672     unsigned v_ = *( reinterpret_cast<unsigned*>( &val ) );
673     if( val <= 0 || (v_ & 0x7f800000) == 0x7f800000 )
674     {
675         return 0;
676     }
677     else
678     {
679         unsigned uval_;
680 
681         val *= 1 << (24 - 16);
682         if (val >= (1 << 24))
683         {
684             uval_ = (1 << 24) - 1;
685         }
686         else
687         {
688             uval_ = (unsigned)(val);
689         }
690 
691         return uval_;
692     }
693 }
694 
695 }  // namespace CTR
696 }  // namespace gd
697 }  // namespace nn
698 
699 #endif // NN_GD_CTR_GD_UTILS_H_
700