home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / h / vd2 / system / binary.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  8.2 KB  |  185 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    System library component
  3. //    Copyright (C) 1998-2004 Avery Lee, All Rights Reserved.
  4. //
  5. //    Beginning with 1.6.0, the VirtualDub system library is licensed
  6. //    differently than the remainder of VirtualDub.  This particular file is
  7. //    thus licensed as follows (the "zlib" license):
  8. //
  9. //    This software is provided 'as-is', without any express or implied
  10. //    warranty.  In no event will the authors be held liable for any
  11. //    damages arising from the use of this software.
  12. //
  13. //    Permission is granted to anyone to use this software for any purpose,
  14. //    including commercial applications, and to alter it and redistribute it
  15. //    freely, subject to the following restrictions:
  16. //
  17. //    1.    The origin of this software must not be misrepresented; you must
  18. //        not claim that you wrote the original software. If you use this
  19. //        software in a product, an acknowledgment in the product
  20. //        documentation would be appreciated but is not required.
  21. //    2.    Altered source versions must be plainly marked as such, and must
  22. //        not be misrepresented as being the original software.
  23. //    3.    This notice may not be removed or altered from any source
  24. //        distribution.
  25.  
  26. #ifndef f_VD2_SYSTEM_BINARY_H
  27. #define f_VD2_SYSTEM_BINARY_H
  28.  
  29. #ifdef _MSC_VER
  30.     #pragma once
  31. #endif
  32.  
  33. #include <vd2/system/vdtypes.h>
  34.  
  35. #define VDMAKEFOURCC(byte1, byte2, byte3, byte4) (((uint8)byte1) + (((uint8)byte2) << 8) + (((uint8)byte3) << 16) + (((uint8)byte4) << 24))
  36.  
  37. #ifdef _MSC_VER
  38.     unsigned short _byteswap_ushort(unsigned short);
  39.     unsigned long _byteswap_ulong(unsigned long);
  40.     unsigned __int64 _byteswap_uint64(unsigned __int64);
  41.  
  42.     #pragma intrinsic(_byteswap_ushort)
  43.     #pragma intrinsic(_byteswap_ulong)
  44.     #pragma intrinsic(_byteswap_uint64)
  45.  
  46.     inline uint16 VDSwizzleU16(uint16 value) { return (uint16)_byteswap_ushort((unsigned short)value); }
  47.     inline sint16 VDSwizzleS16(sint16 value) { return (sint16)_byteswap_ushort((unsigned short)value); }
  48.     inline uint32 VDSwizzleU32(uint32 value) { return (uint32)_byteswap_ulong((unsigned long)value); }
  49.     inline sint32 VDSwizzleS32(sint32 value) { return (sint32)_byteswap_ulong((unsigned long)value); }
  50.     inline uint64 VDSwizzleU64(uint64 value) { return (uint32)_byteswap_uint64((unsigned __int64)value); }
  51.     inline sint64 VDSwizzleS64(sint64 value) { return (sint32)_byteswap_uint64((unsigned __int64)value); }
  52. #else
  53.     inline uint16 VDSwizzleU16(uint16 value) {
  54.         return (value >> 8) + (value >> 8);
  55.     }
  56.  
  57.     inline sint16 VDSwizzleS16(sint16 value) {
  58.         return (sint16)(((uint16)value >> 8) + ((uint16)value >> 8));
  59.     }
  60.  
  61.     inline uint32 VDSwizzleU32(uint32 value) {
  62.         return (value >> 24) + (value << 24) + ((value&0xff00)<<8) + ((value&0xff0000)>>8);
  63.     }
  64.  
  65.     inline sint32 VDSwizzleS32(sint32 value) {
  66.         return (sint32)(((uint32)value >> 24) + ((uint32)value << 24) + (((uint32)value&0xff00)<<8) + (((uint32)value&0xff0000)>>8));
  67.     }
  68.  
  69.     inline uint64 VDSwizzleU64(uint64 value) {
  70.         return    ((value & 0xFF00000000000000) >> 56) +
  71.                 ((value & 0x00FF000000000000) >> 40) +
  72.                 ((value & 0x0000FF0000000000) >> 24) +
  73.                 ((value & 0x000000FF00000000) >>  8) +
  74.                 ((value & 0x00000000FF000000) <<  8) +
  75.                 ((value & 0x0000000000FF0000) << 24) +
  76.                 ((value & 0x000000000000FF00) << 40) +
  77.                 ((value & 0x00000000000000FF) << 56);
  78.     }
  79.  
  80.     inline sint64 VDSwizzleS64(sint64 value) {
  81.         return (sint64)((((uint64)value & 0xFF00000000000000) >> 56) +
  82.                         (((uint64)value & 0x00FF000000000000) >> 40) +
  83.                         (((uint64)value & 0x0000FF0000000000) >> 24) +
  84.                         (((uint64)value & 0x000000FF00000000) >>  8) +
  85.                         (((uint64)value & 0x00000000FF000000) <<  8) +
  86.                         (((uint64)value & 0x0000000000FF0000) << 24) +
  87.                         (((uint64)value & 0x000000000000FF00) << 40) +
  88.                         (((uint64)value & 0x00000000000000FF) << 56));
  89.     }
  90. #endif
  91.  
  92. inline uint16 VDReadUnalignedU16(const void *p) { return *(uint16 *)p; }
  93. inline sint16 VDReadUnalignedS16(const void *p) { return *(sint16 *)p; }
  94. inline uint32 VDReadUnalignedU32(const void *p) { return *(uint32 *)p; }
  95. inline sint32 VDReadUnalignedS32(const void *p) { return *(sint32 *)p; }
  96. inline uint64 VDReadUnalignedU64(const void *p) { return *(uint64 *)p; }
  97. inline sint64 VDReadUnalignedS64(const void *p) { return *(sint64 *)p; }
  98. inline float VDReadUnalignedF(const void *p) { return *(float *)p; }
  99. inline double VDReadUnalignedD(const void *p) { return *(double *)p; }
  100.  
  101. inline uint16 VDReadUnalignedLEU16(const void *p) { return *(uint16 *)p; }
  102. inline sint16 VDReadUnalignedLES16(const void *p) { return *(sint16 *)p; }
  103. inline uint32 VDReadUnalignedLEU32(const void *p) { return *(uint32 *)p; }
  104. inline sint32 VDReadUnalignedLES32(const void *p) { return *(sint32 *)p; }
  105. inline uint64 VDReadUnalignedLEU64(const void *p) { return *(uint64 *)p; }
  106. inline sint64 VDReadUnalignedLES64(const void *p) { return *(sint64 *)p; }
  107. inline float VDReadUnalignedLEF(const void *p) { return *(float *)p; }
  108. inline double VDReadUnalignedLED(const void *p) { return *(double *)p; }
  109.  
  110. inline uint16 VDReadUnalignedBEU16(const void *p) { return VDSwizzleU16(*(uint16 *)p); }
  111. inline sint16 VDReadUnalignedBES16(const void *p) { return VDSwizzleS16(*(sint16 *)p); }
  112. inline uint32 VDReadUnalignedBEU32(const void *p) { return VDSwizzleU32(*(uint32 *)p); }
  113. inline sint32 VDReadUnalignedBES32(const void *p) { return VDSwizzleS32(*(sint32 *)p); }
  114. inline uint64 VDReadUnalignedBEU64(const void *p) { return VDSwizzleU64(*(uint64 *)p); }
  115. inline sint64 VDReadUnalignedBES64(const void *p) { return VDSwizzleS64(*(sint64 *)p); }
  116. inline float VDReadUnalignedBEF(const void *p) {
  117.     union {
  118.         uint32 i;
  119.         float f;
  120.     } conv = {VDSwizzleU32(*(const uint32 *)p)};
  121.     return conv.f;
  122. }
  123. inline double VDReadUnalignedBED(const void *p) {
  124.     union {
  125.         uint64 i;
  126.         double d;
  127.     } conv = {VDSwizzleU64(*(const uint32 *)p)};
  128.     return conv.d;
  129. }
  130.  
  131. inline void VDWriteUnalignedU16  (void *p, uint16 v) { *(uint16 *)p = v; }
  132. inline void VDWriteUnalignedS16  (void *p, sint16 v) { *(sint16 *)p = v; }
  133. inline void VDWriteUnalignedU32  (void *p, uint32 v) { *(uint32 *)p = v; }
  134. inline void VDWriteUnalignedS32  (void *p, sint32 v) { *(sint32 *)p = v; }
  135. inline void VDWriteUnalignedU64  (void *p, uint64 v) { *(uint64 *)p = v; }
  136. inline void VDWriteUnalignedS64  (void *p, sint64 v) { *(sint64 *)p = v; }
  137. inline void VDWriteUnalignedF    (void *p, float  v) { *(float  *)p = v; }
  138. inline void VDWriteUnalignedD    (void *p, double v) { *(double *)p = v; }
  139.  
  140. inline void VDWriteUnalignedLEU16(void *p, uint16 v) { *(uint16 *)p = v; }
  141. inline void VDWriteUnalignedLES16(void *p, sint16 v) { *(sint16 *)p = v; }
  142. inline void VDWriteUnalignedLEU32(void *p, uint32 v) { *(uint32 *)p = v; }
  143. inline void VDWriteUnalignedLES32(void *p, sint32 v) { *(sint32 *)p = v; }
  144. inline void VDWriteUnalignedLEU64(void *p, uint64 v) { *(uint64 *)p = v; }
  145. inline void VDWriteUnalignedLES64(void *p, sint64 v) { *(sint64 *)p = v; }
  146. inline void VDWriteUnalignedLEF  (void *p, float  v) { *(float  *)p = v; }
  147. inline void VDWriteUnalignedLED  (void *p, double v) { *(double *)p = v; }
  148.  
  149. inline void VDWriteUnalignedBEU16(void *p, uint16 v) { *(uint16 *)p = VDSwizzleU16(v); }
  150. inline void VDWriteUnalignedBES16(void *p, sint16 v) { *(sint16 *)p = VDSwizzleS16(v); }
  151. inline void VDWriteUnalignedBEU32(void *p, uint32 v) { *(uint32 *)p = VDSwizzleU32(v); }
  152. inline void VDWriteUnalignedBES32(void *p, sint32 v) { *(sint32 *)p = VDSwizzleS32(v); }
  153. inline void VDWriteUnalignedBEU64(void *p, uint64 v) { *(uint64 *)p = VDSwizzleU64(v); }
  154. inline void VDWriteUnalignedBES64(void *p, sint64 v) { *(sint64 *)p = VDSwizzleS64(v); }
  155. inline void VDReadUnalignedBEF(void *p, float v) {
  156.     union {
  157.         float f;
  158.         uint32 i;
  159.     } conv = {v};
  160.     *(uint32 *)p = VDSwizzleU32(conv.i);
  161. }
  162. inline double VDReadUnalignedBED(void *p, double v) {
  163.     union {
  164.         double f;
  165.         uint64 i;
  166.     } conv = {v};
  167.     *(uint64 *)p = VDSwizzleU64(conv.i);
  168. }
  169.  
  170. #define VDFromLE8(x)    (x)
  171. #define VDFromLE16(x)    (x)
  172. #define VDFromLE32(x)    (x)
  173. #define VDFromBE8(x)    VDSwizzleU8(x)
  174. #define VDFromBE16(x)    VDSwizzleU16(x)
  175. #define VDFromBE32(x)    VDSwizzleU32(x)
  176.  
  177. #define VDToLE8(x)        (x)
  178. #define VDToLE16(x)        (x)
  179. #define VDToLE32(x)        (x)
  180. #define VDToBE8(x)        VDSwizzleU8(x)
  181. #define VDToBE16(x)        VDSwizzleU16(x)
  182. #define VDToBE32(x)        VDSwizzleU32(x)
  183.  
  184. #endif
  185.