1 /* Copyright (C) 2010-2016 The RetroArch team
2 *
3 * ---------------------------------------------------------------------------------------
4 * The following license statement only applies to this file (retro_miscellaneous.h).
5 * ---------------------------------------------------------------------------------------
6 *
7 * Permission is hereby granted, free of charge,
8 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
11 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
19 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 #ifndef __RARCH_MISCELLANEOUS_H
24 #define __RARCH_MISCELLANEOUS_H
25
26 #include <stdint.h>
27 #include <math.h>
28
29 #if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
30 #include <sys/timer.h>
31 #elif defined(XENON)
32 #include <time/time.h>
33 #elif(defined(GEKKO) && !defined(WIIU)) || defined(__PSL1GHT__) || defined(__QNX__)
34 #include <unistd.h>
35 #elif defined(WIIU)
36 #include <wiiu/types.h>
37 #include <wiiu/os/time.h>
38 #include <features_cpu.h>
39 #elif defined(PSP)
40 #include <pspthreadman.h>
41 #elif defined(VITA)
42 #include <psp2/kernel/threadmgr.h>
43 #elif defined(_3DS)
44 #include <3ds.h>
45 #else
46 #include <time.h>
47 #endif
48
49 #if defined(_WIN32) && !defined(_XBOX)
50 #define WIN32_LEAN_AND_MEAN
51 #include <windows.h>
52 #elif defined(_WIN32) && defined(_XBOX)
53 #include <Xtl.h>
54 #endif
55
56 #include <limits.h>
57 #include <math.h>
58
59 #ifdef _MSC_VER
60 #include <compat/msvc.h>
61 #endif
62 #include <retro_inline.h>
63
64 #ifndef PATH_MAX_LENGTH
65 #if defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(GEKKO)|| defined(WIIU)
66 #define PATH_MAX_LENGTH 512
67 #else
68 #define PATH_MAX_LENGTH 4096
69 #endif
70 #endif
71
72 #ifndef M_PI
73 #define M_PI 3.14159265358979323846264338327
74 #endif
75
76 #ifndef MAX
77 #define MAX(a, b) ((a) > (b) ? (a) : (b))
78 #endif
79
80 #ifndef MIN
81 #define MIN(a, b) ((a) < (b) ? (a) : (b))
82 #endif
83
84 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
85 #define RARCH_SCALE_BASE 256
86
87 /**
88 * retro_sleep:
89 * @msec : amount in milliseconds to sleep
90 *
91 * Sleeps for a specified amount of milliseconds (@msec).
92 **/
retro_sleep(unsigned msec)93 static INLINE void retro_sleep(unsigned msec)
94 {
95 #if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
96 sys_timer_usleep(1000 * msec);
97 #elif defined(PSP) || defined(VITA)
98 sceKernelDelayThread(1000 * msec);
99 #elif defined(_3DS)
100 svcSleepThread(1000000 * (s64)msec);
101 #elif defined(_WIN32)
102 Sleep(msec);
103 #elif defined(XENON)
104 udelay(1000 * msec);
105 #elif (defined(GEKKO) && !defined(WIIU)) || defined(__PSL1GHT__) || defined(__QNX__)
106 usleep(1000 * msec);
107 #elif defined(WIIU)
108 OSSleepTicks(ms_to_ticks(msec));
109 #else
110 struct timespec tv = {0};
111 tv.tv_sec = msec / 1000;
112 tv.tv_nsec = (msec % 1000) * 1000000;
113 nanosleep(&tv, NULL);
114 #endif
115 }
116
117 /**
118 * next_pow2:
119 * @v : initial value
120 *
121 * Get next power of 2 value based on initial value.
122 *
123 * Returns: next power of 2 value (derived from @v).
124 **/
next_pow2(uint32_t v)125 static INLINE uint32_t next_pow2(uint32_t v)
126 {
127 v--;
128 v |= v >> 1;
129 v |= v >> 2;
130 v |= v >> 4;
131 v |= v >> 8;
132 v |= v >> 16;
133 v++;
134 return v;
135 }
136
137 /**
138 * prev_pow2:
139 * @v : initial value
140 *
141 * Get previous power of 2 value based on initial value.
142 *
143 * Returns: previous power of 2 value (derived from @v).
144 **/
prev_pow2(uint32_t v)145 static INLINE uint32_t prev_pow2(uint32_t v)
146 {
147 v |= v >> 1;
148 v |= v >> 2;
149 v |= v >> 4;
150 v |= v >> 8;
151 v |= v >> 16;
152 return v - (v >> 1);
153 }
154
155 /**
156 * db_to_gain:
157 * @db : Decibels.
158 *
159 * Converts decibels to voltage gain.
160 *
161 * Returns: voltage gain value.
162 **/
db_to_gain(float db)163 static INLINE float db_to_gain(float db)
164 {
165 return powf(10.0f, db / 20.0f);
166 }
167
read_le(const uint8_t * data,unsigned size)168 static INLINE uint32_t read_le(const uint8_t *data, unsigned size)
169 {
170 unsigned i;
171 uint32_t val = 0;
172
173 size *= 8;
174 for (i = 0; i < size; i += 8)
175 val |= (uint32_t)*data++ << i;
176
177 return val;
178 }
179
180 /* Helper macros and struct to keep track of many booleans.
181 * To check for multiple bits, use &&, not &.
182 * For OR, | can be used. */
183 typedef struct
184 {
185 uint32_t data[8];
186 } retro_bits_t;
187
188 #define BIT_SET(a, bit) ((a)[(bit) >> 3] |= (1 << ((bit) & 7)))
189 #define BIT_CLEAR(a, bit) ((a)[(bit) >> 3] &= ~(1 << ((bit) & 7)))
190 #define BIT_GET(a, bit) ((a)[(bit) >> 3] & (1 << ((bit) & 7)))
191
192 #define BIT16_SET(a, bit) ((a) |= (1 << ((bit) & 15)))
193 #define BIT16_CLEAR(a, bit) ((a) &= ~(1 << ((bit) & 15)))
194 #define BIT16_GET(a, bit) (!!((a) & (1 << ((bit) & 15))))
195 #define BIT16_CLEAR_ALL(a) ((a) = 0)
196
197 #define BIT32_SET(a, bit) ((a) |= (1 << ((bit) & 31)))
198 #define BIT32_CLEAR(a, bit) ((a) &= ~(1 << ((bit) & 31)))
199 #define BIT32_GET(a, bit) (!!((a) & (1 << ((bit) & 31))))
200 #define BIT32_CLEAR_ALL(a) ((a) = 0)
201
202 #define BIT64_SET(a, bit) ((a) |= (UINT64_C(1) << ((bit) & 63)))
203 #define BIT64_CLEAR(a, bit) ((a) &= ~(UINT64_C(1) << ((bit) & 63)))
204 #define BIT64_GET(a, bit) (!!((a) & (UINT64_C(1) << ((bit) & 63))))
205 #define BIT64_CLEAR_ALL(a) ((a) = 0)
206
207 #define BIT128_SET(a, bit) ((a).data[(bit) >> 5] |= (1 << ((bit) & 31)))
208 #define BIT128_CLEAR(a, bit) ((a).data[(bit) >> 5] &= ~(1 << ((bit) & 31)))
209 #define BIT128_GET(a, bit) ((a).data[(bit) >> 5] & (1 << ((bit) & 31)))
210 #define BIT128_CLEAR_ALL(a) memset(&(a), 0, sizeof(a));
211
212 #endif
213