falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3690 Commits
16 Branches
16GB
Tree: eeaff46212
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'eeaff46212'
${ noResults }
Carla/source/modules/water/memory/juce_ByteOrder.h

242 lines
15KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2016 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of the ISC license

  8.    http://www.isc.org/downloads/software-support-policy/isc-license/

  9. 

  10.    Permission to use, copy, modify, and/or distribute this software for any

  11.    purpose with or without fee is hereby granted, provided that the above

  12.    copyright notice and this permission notice appear in all copies.

  13. 

  14.    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD

  15.    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

  16.    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,

  17.    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

  18.    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

  19.    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

  20.    OF THIS SOFTWARE.

  21. 

  22.    -----------------------------------------------------------------------------

  23. 

  24.    To release a closed-source product which uses other parts of JUCE not

  25.    licensed under the ISC terms, commercial licenses are available: visit

  26.    www.juce.com for more information.

  27. 

  28.   ==============================================================================

  29. */

  30. 

  31. #ifndef JUCE_BYTEORDER_H_INCLUDED

  32. #define JUCE_BYTEORDER_H_INCLUDED

  33. 

  34. 

  35. //==============================================================================

  36. /** Contains static methods for converting the byte order between different

  37.     endiannesses.

  38. */

  39. class JUCE_API  ByteOrder

  40. {

  41. public:

  42.     //==============================================================================

  43.     /** Swaps the upper and lower bytes of a 16-bit integer. */

  44.     static uint16 swap (uint16 value) noexcept;

  45. 

  46.     /** Reverses the order of the 4 bytes in a 32-bit integer. */

  47.     static uint32 swap (uint32 value) noexcept;

  48. 

  49.     /** Reverses the order of the 8 bytes in a 64-bit integer. */

  50.     static uint64 swap (uint64 value) noexcept;

  51. 

  52.     //==============================================================================

  53.     /** Swaps the byte order of a 16-bit unsigned int if the CPU is big-endian */

  54.     static uint16 swapIfBigEndian (uint16 value) noexcept;

  55. 

  56.     /** Swaps the byte order of a 32-bit unsigned int if the CPU is big-endian */

  57.     static uint32 swapIfBigEndian (uint32 value) noexcept;

  58. 

  59.     /** Swaps the byte order of a 64-bit unsigned int if the CPU is big-endian */

  60.     static uint64 swapIfBigEndian (uint64 value) noexcept;

  61. 

  62.     /** Swaps the byte order of a 16-bit signed int if the CPU is big-endian */

  63.     static int16 swapIfBigEndian (int16 value) noexcept;

  64. 

  65.     /** Swaps the byte order of a 32-bit signed int if the CPU is big-endian */

  66.     static int32 swapIfBigEndian (int32 value) noexcept;

  67. 

  68.     /** Swaps the byte order of a 64-bit signed int if the CPU is big-endian */

  69.     static int64 swapIfBigEndian (int64 value) noexcept;

  70. 

  71.     /** Swaps the byte order of a 32-bit float if the CPU is big-endian */

  72.     static float swapIfBigEndian (float value) noexcept;

  73. 

  74.     /** Swaps the byte order of a 64-bit float if the CPU is big-endian */

  75.     static double swapIfBigEndian (double value) noexcept;

  76. 

  77.     /** Swaps the byte order of a 16-bit unsigned int if the CPU is little-endian */

  78.     static uint16 swapIfLittleEndian (uint16 value) noexcept;

  79. 

  80.     /** Swaps the byte order of a 32-bit unsigned int if the CPU is little-endian */

  81.     static uint32 swapIfLittleEndian (uint32 value) noexcept;

  82. 

  83.     /** Swaps the byte order of a 64-bit unsigned int if the CPU is little-endian */

  84.     static uint64 swapIfLittleEndian (uint64 value) noexcept;

  85. 

  86.     /** Swaps the byte order of a 16-bit signed int if the CPU is little-endian */

  87.     static int16 swapIfLittleEndian (int16 value) noexcept;

  88. 

  89.     /** Swaps the byte order of a 32-bit signed int if the CPU is little-endian */

  90.     static int32 swapIfLittleEndian (int32 value) noexcept;

  91. 

  92.     /** Swaps the byte order of a 64-bit signed int if the CPU is little-endian */

  93.     static int64 swapIfLittleEndian (int64 value) noexcept;

  94. 

  95.     /** Swaps the byte order of a 32-bit float if the CPU is little-endian */

  96.     static float swapIfLittleEndian (float value) noexcept;

  97. 

  98.     /** Swaps the byte order of a 64-bit float if the CPU is little-endian */

  99.     static double swapIfLittleEndian (double value) noexcept;

  100. 

  101.     //==============================================================================

  102.     /** Turns 4 bytes into a little-endian integer. */

  103.     static uint32 littleEndianInt (const void* bytes) noexcept;

  104. 

  105.     /** Turns 8 bytes into a little-endian integer. */

  106.     static uint64 littleEndianInt64 (const void* bytes) noexcept;

  107. 

  108.     /** Turns 2 bytes into a little-endian integer. */

  109.     static uint16 littleEndianShort (const void* bytes) noexcept;

  110. 

  111.     /** Turns 4 bytes into a big-endian integer. */

  112.     static uint32 bigEndianInt (const void* bytes) noexcept;

  113. 

  114.     /** Turns 8 bytes into a big-endian integer. */

  115.     static uint64 bigEndianInt64 (const void* bytes) noexcept;

  116. 

  117.     /** Turns 2 bytes into a big-endian integer. */

  118.     static uint16 bigEndianShort (const void* bytes) noexcept;

  119. 

  120.     //==============================================================================

  121.     /** Converts 3 little-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */

  122.     static int littleEndian24Bit (const void* bytes) noexcept;

  123. 

  124.     /** Converts 3 big-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */

  125.     static int bigEndian24Bit (const void* bytes) noexcept;

  126. 

  127.     /** Copies a 24-bit number to 3 little-endian bytes. */

  128.     static void littleEndian24BitToChars (int value, void* destBytes) noexcept;

  129. 

  130.     /** Copies a 24-bit number to 3 big-endian bytes. */

  131.     static void bigEndian24BitToChars (int value, void* destBytes) noexcept;

  132. 

  133.     //==============================================================================

  134.     /** Returns true if the current CPU is big-endian. */

  135.     static bool isBigEndian() noexcept;

  136. 

  137. private:

  138.     ByteOrder() JUCE_DELETED_FUNCTION;

  139. 

  140.     JUCE_DECLARE_NON_COPYABLE (ByteOrder)

  141. };

  142. 

  143. 

  144. //==============================================================================

  145. #if JUCE_MSVC && ! defined (__INTEL_COMPILER)

  146.  #pragma intrinsic (_byteswap_ulong)

  147. #endif

  148. 

  149. inline uint16 ByteOrder::swap (uint16 n) noexcept

  150. {

  151.     return static_cast<uint16> ((n << 8) | (n >> 8));

  152. }

  153. 

  154. inline uint32 ByteOrder::swap (uint32 n) noexcept

  155. {

  156.    #if JUCE_MAC || JUCE_IOS

  157.     return OSSwapInt32 (n);

  158.    #elif (JUCE_GCC  || JUCE_CLANG) && JUCE_INTEL && ! JUCE_NO_INLINE_ASM

  159.     asm("bswap %%eax" : "=a"(n) : "a"(n));

  160.     return n;

  161.    #elif JUCE_MSVC

  162.     return _byteswap_ulong (n);

  163.    #elif JUCE_ANDROID

  164.     return bswap_32 (n);

  165.    #else

  166.     return (n << 24) | (n >> 24) | ((n & 0xff00) << 8) | ((n & 0xff0000) >> 8);

  167.    #endif

  168. }

  169. 

  170. inline uint64 ByteOrder::swap (uint64 value) noexcept

  171. {

  172.    #if JUCE_MAC || JUCE_IOS

  173.     return OSSwapInt64 (value);

  174.    #elif JUCE_MSVC

  175.     return _byteswap_uint64 (value);

  176.    #else

  177.     return (((uint64) swap ((uint32) value)) << 32) | swap ((uint32) (value >> 32));

  178.    #endif

  179. }

  180. 

  181. #ifdef __LITTLE_ENDIAN__

  182.  inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept                                  { return v; }

  183.  inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept                                  { return v; }

  184.  inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept                                  { return v; }

  185.  inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept                                    { return v; }

  186.  inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept                                    { return v; }

  187.  inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept                                    { return v; }

  188.  inline float ByteOrder::swapIfBigEndian (const float v) noexcept                                    { return v; }

  189.  inline double ByteOrder::swapIfBigEndian (const double v) noexcept                                  { return v; }

  190. 

  191.  inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept                               { return swap (v); }

  192.  inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept                               { return swap (v); }

  193.  inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept                               { return swap (v); }

  194.  inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept                                 { return static_cast<int16> (swap (static_cast<uint16> (v))); }

  195.  inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept                                 { return static_cast<int32> (swap (static_cast<uint32> (v))); }

  196.  inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept                                 { return static_cast<int64> (swap (static_cast<uint64> (v))); }

  197. inline float ByteOrder::swapIfLittleEndian (const float v) noexcept                                  { union { uint32 asUInt; float asFloat;  } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }

  198.  inline double ByteOrder::swapIfLittleEndian (const double v) noexcept                               { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }

  199. 

  200.  inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept                         { return *static_cast<const uint32*> (bytes); }

  201.  inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept                       { return *static_cast<const uint64*> (bytes); }

  202.  inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept                       { return *static_cast<const uint16*> (bytes); }

  203.  inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept                            { return swap (*static_cast<const uint32*> (bytes)); }

  204.  inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept                          { return swap (*static_cast<const uint64*> (bytes)); }

  205.  inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept                          { return swap (*static_cast<const uint16*> (bytes)); }

  206.  inline bool ByteOrder::isBigEndian() noexcept                                                       { return false; }

  207. #else

  208.  inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept                                  { return swap (v); }

  209.  inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept                                  { return swap (v); }

  210.  inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept                                  { return swap (v); }

  211.  inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept                                    { return static_cast<int16> (swap (static_cast<uint16> (v))); }

  212.  inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept                                    { return static_cast<int16> (swap (static_cast<uint16> (v))); }

  213.  inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept                                    { return static_cast<int16> (swap (static_cast<uint16> (v))); }

  214.  inline float ByteOrder::swapIfBigEndian (const float v) noexcept                                    { union { uint32 asUInt; float asFloat;  } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }

  215.  inline double ByteOrder::swapIfBigEndian (const double v) noexcept                                  { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }

  216. 

  217.  inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept                               { return v; }

  218.  inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept                               { return v; }

  219.  inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept                               { return v; }

  220.  inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept                                 { return v; }

  221.  inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept                                 { return v; }

  222.  inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept                                 { return v; }

  223.  inline float ByteOrder::swapIfLittleEndian (const float v) noexcept                                 { return v; }

  224.  inline double ByteOrder::swapIfLittleEndian (const double v) noexcept                               { return v; }

  225. 

  226.  inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept                         { return swap (*static_cast<const uint32*> (bytes)); }

  227.  inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept                       { return swap (*static_cast<const uint64*> (bytes)); }

  228.  inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept                       { return swap (*static_cast<const uint16*> (bytes)); }

  229.  inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept                            { return *static_cast<const uint32*> (bytes); }

  230.  inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept                          { return *static_cast<const uint64*> (bytes); }

  231.  inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept                          { return *static_cast<const uint16*> (bytes); }

  232.  inline bool ByteOrder::isBigEndian() noexcept                                                       { return true; }

  233. #endif

  234. 

  235. inline int  ByteOrder::littleEndian24Bit (const void* const bytes) noexcept                          { return (((int) static_cast<const int8*> (bytes)[2]) << 16) | (((int) static_cast<const uint8*> (bytes)[1]) << 8) | ((int) static_cast<const uint8*> (bytes)[0]); }

  236. inline int  ByteOrder::bigEndian24Bit (const void* const bytes) noexcept                             { return (((int) static_cast<const int8*> (bytes)[0]) << 16) | (((int) static_cast<const uint8*> (bytes)[1]) << 8) | ((int) static_cast<const uint8*> (bytes)[2]); }

  237. inline void ByteOrder::littleEndian24BitToChars (const int value, void* const destBytes) noexcept    { static_cast<uint8*> (destBytes)[0] = (uint8) value;         static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) (value >> 16); }

  238. inline void ByteOrder::bigEndian24BitToChars (const int value, void* const destBytes) noexcept       { static_cast<uint8*> (destBytes)[0] = (uint8) (value >> 16); static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) value; }

  239. 

  240. 

  241. #endif   // JUCE_BYTEORDER_H_INCLUDED