Debian Codegraph @

core/libs/dngwriter/extra/xmp_sdk/source/EndianUtils.hpp

raw
1 #ifndef __EndianUtils_hpp__
2 #define __EndianUtils_hpp__ 1
3
4 // =================================================================================================
5 // ADOBE SYSTEMS INCORPORATED
6 // Copyright 2006 Adobe Systems Incorporated
7 // All Rights Reserved
8 //
9 // NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
10 // of the Adobe license agreement accompanying it.
11 // =================================================================================================
12
13 #if AdobePrivate
14 // =================================================================================================
15 // Change history
16 // ==============
17 //
18 // Writers:
19 // AWL Alan Lillich
20 // HK Honey Kansal
21 //
22 // mm-dd-yy who Description of changes, most recent on top
23 //
24 // 01-03-14 HK 5.6-f087 [3688857] Fixing data alignment issues on ARM processor.
25 //
26 // 02-15-08 AWL 4.2-f075 Integrate more folder-oriented handler updates. Initial changes to create
27 // generic UNIX builds for XMPFiles.
28 //
29 // 11-08-06 AWL 4.1-f062 Consolidate the endian conversion routines in EndianUtils.hpp.
30 //
31 // 04-14-06 AWL Extract as separate file from TIFF_Support.cpp.
32 //
33 // =================================================================================================
34 #endif // AdobePrivate
35
36 #include "public/include/XMP_Environment.h" // ! This must be the first include.
37 #include "public/include/XMP_Const.h"
38
39 #if SUNOS_SPARC || SUNOS || XMP_IOS_ARM || XMP_ANDROID_ARM
40 #include "string.h"
41 #endif //SUNOS_SPARC || SUNOS || XMP_IOS_ARM || XMP_ANDROID_ARM
42
43 // *** These should be in a more common location. The Unicode conversions of XMPCore have similar utils.
44 // *** May want to improve with PowerPC swapping load/store, or SSE instructions.
45
46 // =================================================================================================
47
48 #define kLittleEndianHost (! kBigEndianHost)
49 #if XMP_WinBuild
50 #pragma warning ( disable : 4127 ) // conditional expression is constant
51 #define kBigEndianHost 0
52 #elif XMP_MacBuild | XMP_iOSBuild
53 #if __BIG_ENDIAN__
54 #define kBigEndianHost 1
55 #elif __LITTLE_ENDIAN__
56 #define kBigEndianHost 0
57 #else
58 #error "Neither __BIG_ENDIAN__ nor __LITTLE_ENDIAN__ is set"
59 #endif
60 #elif XMP_AndroidBuild
61 #if __BIG_ENDIAN__
62 #define kBigEndianHost 1
63 #elif __LITTLE_ENDIAN__
64 #define kBigEndianHost 0
65 #else
66 #error "Neither __BIG_ENDIAN__ nor __LITTLE_ENDIAN__ is set"
67 #endif
68 #elif XMP_UNIXBuild
69 #ifndef kBigEndianHost // Typically in the makefile for generic UNIX.
70 #if __GNUC__ && (__i386__ || __x86_64__ || __aarch64__)
71 #define kBigEndianHost 0
72 #elif __GNUC__ && (__sparc__)
73 #define kBigEndianHost 1
74 #define kLittleEndianHost 0
75 #elif __EMSCRIPTEN__
76 #define kBigEndianHost 0
77 #else
78 #error "Must define kBigEndianHost as 0 or 1 in the makefile."
79 #endif
80 #endif
81 #else
82 #error "Unknown build environment"
83 #endif
84
85 // =================================================================================================
86
87 typedef XMP_Uns16 (*GetUns16_Proc) ( const void* addr );
88 typedef XMP_Uns32 (*GetUns32_Proc) ( const void* addr );
89 typedef XMP_Uns64 (*GetUns64_Proc) ( const void* addr );
90 typedef float (*GetFloat_Proc) ( const void* addr );
91 typedef double (*GetDouble_Proc) ( const void* addr );
92
93 typedef XMP_Uns16 (*MakeUns16_Proc) ( XMP_Uns16 value );
94 typedef XMP_Uns32 (*MakeUns32_Proc) ( XMP_Uns32 value );
95 typedef XMP_Uns64 (*MakeUns64_Proc) ( XMP_Uns64 value );
96 typedef float (*MakeFloat_Proc) ( float value );
97 typedef double (*MakeDouble_Proc) ( double value );
98
99 typedef void (*PutUns16_Proc) ( XMP_Uns16 value, void* addr );
100 typedef void (*PutUns32_Proc) ( XMP_Uns32 value, void* addr );
101 typedef void (*PutUns64_Proc) ( XMP_Uns64 value, void* addr );
102 typedef void (*PutFloat_Proc) ( float value, void* addr );
103 typedef void (*PutDouble_Proc) ( double value, void* addr );
104
105 // =================================================================================================
106
107 #if SUNOS_SPARC || SUNOS || XMP_IOS_ARM || XMP_ANDROID_ARM
108 #define DefineAndGetValue(type,addr) type value = 0; memcpy ( &value, addr, sizeof(type) )
109 #define DefineAndSetValue(type,addr) memcpy(addr, &value, sizeof(type))
110 #define DefineFlipAndSet(type,x,addr) type temp; memcpy(&temp, addr, sizeof(type)); temp = Flip##x(temp); memcpy(addr, &temp, sizeof(type))
111 #else
112 #define DefineAndGetValue(type,addr) type value = *((type*)addr)
113 #define DefineAndSetValue(type,addr) *((type*)addr) = value
114 #define DefineFlipAndSet(type,x,addr) type* uPtr = (type*) addr; *uPtr = Flip##x ( *uPtr )
115 #endif //#if SUNOS_SPARC || SUNOS || XMP_IOS_ARM || XMP_ANDROID_ARM || XMP_ANDROID_ARM
116
117 // -------------------------------------------------------------------------------------------------
118
119 static inline XMP_Uns16 Flip2 ( XMP_Uns16 value )
120 {
121 value = ((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8);
122 return value;
123 }
124
125 // -------------------------------------------------------------------------------------------------
126
127 static inline void Flip2 ( void * addr )
128 {
129 DefineFlipAndSet ( XMP_Uns16, 2, addr );
130 }
131
132 // -------------------------------------------------------------------------------------------------
133
134 static inline XMP_Uns32 Flip4 ( XMP_Uns32 value )
135 {
136 value = ((value & 0x000000FF) << 24) | ((value & 0x0000FF00) << 8) |
137 ((value >> 8) & 0x0000FF00) | ((value >> 24) & 0x000000FF);
138 return value;
139 }
140
141 // -------------------------------------------------------------------------------------------------
142
143 static inline void Flip4 ( void * addr )
144 {
145 DefineFlipAndSet ( XMP_Uns32, 4, addr );
146 }
147
148 // -------------------------------------------------------------------------------------------------
149
150 static inline XMP_Uns64 Flip8 ( XMP_Uns64 value )
151 {
152 XMP_Uns32 oldLow = (XMP_Uns32)(value);
153 XMP_Uns32 oldHigh = (XMP_Uns32)(value >> 32);
154 return (((XMP_Uns64)Flip4(oldLow)) << 32) | ((XMP_Uns64)Flip4(oldHigh));
155 }
156
157 // -------------------------------------------------------------------------------------------------
158
159 static inline void Flip8 ( void * addr )
160 {
161 DefineFlipAndSet ( XMP_Uns64, 8, addr );
162 }
163
164 // =================================================================================================
165
166 static inline XMP_Uns16 GetUns16BE ( const void * addr )
167 {
168 DefineAndGetValue ( XMP_Uns16, addr );
169 if ( kLittleEndianHost ) value = Flip2 ( value );
170 return value;
171 }
172
173 // -------------------------------------------------------------------------------------------------
174
175 static inline XMP_Uns16 GetUns16LE ( const void * addr )
176 {
177 DefineAndGetValue ( XMP_Uns16, addr );
178 if ( kBigEndianHost ) value = Flip2 ( value );
179 return value;
180 }
181
182 // -------------------------------------------------------------------------------------------------
183
184 static inline XMP_Uns16 GetUns16AsIs ( const void * addr )
185 {
186 DefineAndGetValue ( XMP_Uns16, addr );
187 return value; // Use this to avoid SPARC failure to handle unaligned loads and stores.
188 }
189
190 // -------------------------------------------------------------------------------------------------
191
192 static inline XMP_Uns32 GetUns32BE ( const void * addr )
193 {
194 DefineAndGetValue ( XMP_Uns32, addr );
195 if ( kLittleEndianHost ) value = Flip4 ( value );
196 return value;
197 }
198
199 // -------------------------------------------------------------------------------------------------
200
201 static inline XMP_Uns32 GetUns32LE ( const void * addr )
202 {
203 DefineAndGetValue ( XMP_Uns32, addr );
204 if ( kBigEndianHost ) value = Flip4 ( value );
205 return value;
206 }
207
208 // -------------------------------------------------------------------------------------------------
209
210 static inline XMP_Uns32 GetUns32AsIs ( const void * addr )
211 {
212 DefineAndGetValue ( XMP_Uns32, addr );
213 return value; // Use this to avoid SPARC failure to handle unaligned loads and stores.
214 }
215
216 // -------------------------------------------------------------------------------------------------
217
218 static inline XMP_Uns64 GetUns64BE ( const void * addr )
219 {
220 DefineAndGetValue ( XMP_Uns64, addr );
221 if ( kLittleEndianHost ) value = Flip8 ( value );
222 return value;
223 }
224
225 // -------------------------------------------------------------------------------------------------
226
227 static inline XMP_Uns64 GetUns64LE ( const void * addr )
228 {
229 DefineAndGetValue ( XMP_Uns64, addr );
230 if ( kBigEndianHost ) value = Flip8 ( value );
231 return value;
232 }
233
234 // -------------------------------------------------------------------------------------------------
235
236 static inline XMP_Uns64 GetUns64AsIs ( const void * addr )
237 {
238 DefineAndGetValue ( XMP_Uns64, addr );
239 return value; // Use this to avoid SPARC failure to handle unaligned loads and stores.
240 }
241
242 // -------------------------------------------------------------------------------------------------
243
244 static inline float
245 GetFloatBE ( const void * addr )
246 {
247 XMP_Uns32 value = *((XMP_Uns32*)addr);
248 if ( kLittleEndianHost ) value = Flip4 ( value );
249 return *((float*)&value);
250 }
251
252 // -------------------------------------------------------------------------------------------------
253
254 static inline float
255 GetFloatLE ( const void * addr )
256 {
257 XMP_Uns32 value = *((XMP_Uns32*)addr);
258 if ( kBigEndianHost ) value = Flip4 ( value );
259 return *((float*)&value);
260 }
261
262 // -------------------------------------------------------------------------------------------------
263
264 static inline double
265 GetDoubleBE ( const void * addr )
266 {
267 XMP_Uns64 value = *((XMP_Uns64*)addr);
268 if ( kLittleEndianHost ) value = Flip8 ( value );
269 return *((double*)&value);
270 }
271
272 // -------------------------------------------------------------------------------------------------
273
274 static inline double
275 GetDoubleLE ( const void * addr )
276 {
277 XMP_Uns64 value = *((XMP_Uns64*)addr);
278 if ( kBigEndianHost ) value = Flip8 ( value );
279 return *((double*)&value);
280 }
281
282 // =================================================================================================
283
284 static inline XMP_Uns16
285 MakeUns16BE ( XMP_Uns16 value )
286 {
287 if ( kLittleEndianHost ) value = Flip2 ( value );
288 return value;
289 }
290
291 // -------------------------------------------------------------------------------------------------
292
293 static inline XMP_Uns16
294 MakeUns16LE ( XMP_Uns16 value )
295 {
296 if ( kBigEndianHost ) value = Flip2 ( value );
297 return value;
298 }
299
300 // -------------------------------------------------------------------------------------------------
301
302 static inline XMP_Uns32
303 MakeUns32BE ( XMP_Uns32 value )
304 {
305 if ( kLittleEndianHost ) value = Flip4 ( value );
306 return value;
307 }
308
309 // -------------------------------------------------------------------------------------------------
310
311 static inline XMP_Uns32
312 MakeUns32LE ( XMP_Uns32 value )
313 {
314 if ( kBigEndianHost ) value = Flip4 ( value );
315 return value;
316 }
317
318 // -------------------------------------------------------------------------------------------------
319
320 static inline XMP_Uns64
321 MakeUns64BE ( XMP_Uns64 value )
322 {
323 if ( kLittleEndianHost ) value = Flip8 ( value );
324 return value;
325 }
326
327 // -------------------------------------------------------------------------------------------------
328
329 static inline XMP_Uns64
330 MakeUns64LE ( XMP_Uns64 value )
331 {
332 if ( kBigEndianHost ) value = Flip8 ( value );
333 return value;
334 }
335
336 // -------------------------------------------------------------------------------------------------
337
338 static inline float
339 MakeFloatBE ( float value )
340 {
341 if ( kLittleEndianHost ) {
342 XMP_Uns32* intPtr = (XMP_Uns32*) &value;
343 *intPtr = Flip4 ( *intPtr );
344 }
345 return value;
346 }
347
348 // -------------------------------------------------------------------------------------------------
349
350 static inline float
351 MakeFloatLE ( float value )
352 {
353 if ( kBigEndianHost ) {
354 XMP_Uns32* intPtr = (XMP_Uns32*) &value;
355 *intPtr = Flip4 ( *intPtr );
356 }
357 return value;
358 }
359
360 // -------------------------------------------------------------------------------------------------
361
362 static inline double
363 MakeDoubleBE ( double value )
364 {
365 if ( kLittleEndianHost ) {
366 XMP_Uns64* intPtr = (XMP_Uns64*) &value;
367 *intPtr = Flip8 ( *intPtr );
368 }
369 return value;
370 }
371
372 // -------------------------------------------------------------------------------------------------
373
374 static inline double
375 MakeDoubleLE ( double value )
376 {
377 if ( kBigEndianHost ) {
378 XMP_Uns64* intPtr = (XMP_Uns64*) &value;
379 *intPtr = Flip8 ( *intPtr );
380 }
381 return value;
382 }
383
384 // =================================================================================================
385
386 static inline void PutUns16BE ( XMP_Uns16 value, void * addr )
387 {
388 if ( kLittleEndianHost ) value = Flip2 ( value );
389 DefineAndSetValue ( XMP_Uns16, addr );
390 }
391
392 // -------------------------------------------------------------------------------------------------
393
394 static inline void PutUns16LE ( XMP_Uns16 value, void * addr )
395 {
396 if ( kBigEndianHost ) value = Flip2 ( value );
397 DefineAndSetValue ( XMP_Uns16, addr );
398 }
399
400 // -------------------------------------------------------------------------------------------------
401
402 static inline void PutUns16AsIs ( XMP_Uns16 value, void * addr )
403 {
404 DefineAndSetValue ( XMP_Uns16, addr ); // Use this to avoid SPARC failure to handle unaligned loads and stores.
405 }
406
407 // -------------------------------------------------------------------------------------------------
408
409 static inline void PutUns32BE ( XMP_Uns32 value, void * addr )
410 {
411 if ( kLittleEndianHost ) value = Flip4 ( value );
412 DefineAndSetValue ( XMP_Uns32, addr );
413 }
414
415 // -------------------------------------------------------------------------------------------------
416
417 static inline void PutUns32LE ( XMP_Uns32 value, void * addr )
418 {
419 if ( kBigEndianHost ) value = Flip4 ( value );
420 DefineAndSetValue ( XMP_Uns32, addr );
421 }
422
423 // -------------------------------------------------------------------------------------------------
424
425 static inline void PutUns32AsIs ( XMP_Uns32 value, void * addr )
426 {
427 DefineAndSetValue ( XMP_Uns32, addr ); // Use this to avoid SPARC failure to handle unaligned loads and stores.
428 }
429
430 // -------------------------------------------------------------------------------------------------
431
432 static inline void PutUns64BE ( XMP_Uns64 value, void * addr )
433 {
434 if ( kLittleEndianHost ) value = Flip8 ( value );
435 DefineAndSetValue ( XMP_Uns64, addr );
436 }
437
438 // -------------------------------------------------------------------------------------------------
439
440 static inline void PutUns64LE ( XMP_Uns64 value, void * addr )
441 {
442 if ( kBigEndianHost ) value = Flip8 ( value );
443 DefineAndSetValue ( XMP_Uns64, addr );
444 }
445
446 // -------------------------------------------------------------------------------------------------
447
448 static inline void PutUns64AsIs ( XMP_Uns64 value, void * addr )
449 {
450 DefineAndSetValue ( XMP_Uns64, addr ); // Use this to avoid SPARC failure to handle unaligned loads and stores.
451 }
452
453 // -------------------------------------------------------------------------------------------------
454
455 static inline void
456 PutFloatBE ( float value, void * addr )
457 {
458 if ( kLittleEndianHost ) {
459 XMP_Uns32* intPtr = (XMP_Uns32*) &value;
460 *intPtr = Flip4 ( *intPtr );
461 }
462 *((float*)addr) = value;
463 }
464
465 // -------------------------------------------------------------------------------------------------
466
467 static inline void
468 PutFloatLE ( float value, void * addr )
469 {
470 if ( kBigEndianHost ) {
471 XMP_Uns32* intPtr = (XMP_Uns32*) &value;
472 *intPtr = Flip4 ( *intPtr );
473 }
474 *((float*)addr) = value;
475 }
476
477 // -------------------------------------------------------------------------------------------------
478
479 static inline void
480 PutDoubleBE ( double value, void * addr )
481 {
482 if ( kLittleEndianHost ) {
483 XMP_Uns64* intPtr = (XMP_Uns64*) &value;
484 *intPtr = Flip8 ( *intPtr );
485 }
486 *((double*)addr) = value;
487 }
488
489 // -------------------------------------------------------------------------------------------------
490
491 static inline void
492 PutDoubleLE ( double value, void * addr )
493 {
494 if ( kBigEndianHost ) {
495 XMP_Uns64* intPtr = (XMP_Uns64*) &value;
496 *intPtr = Flip8 ( *intPtr );
497 }
498 *((double*)addr) = value;
499 }
500
501 // =================================================================================================
502
503 #endif // __EndianUtils_hpp__