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