Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * This file is part of FFmpeg.
  3.  *
  4.  * FFmpeg is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Lesser General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2.1 of the License, or (at your option) any later version.
  8.  *
  9.  * FFmpeg is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with FFmpeg; if not, write to the Free Software
  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17.  */
  18.  
  19. #ifndef AVUTIL_INTREADWRITE_H
  20. #define AVUTIL_INTREADWRITE_H
  21.  
  22. #include <stdint.h>
  23. #include "libavutil/avconfig.h"
  24. #include "attributes.h"
  25. #include "bswap.h"
  26.  
  27. typedef union {
  28.     uint64_t u64;
  29.     uint32_t u32[2];
  30.     uint16_t u16[4];
  31.     uint8_t  u8 [8];
  32.     double   f64;
  33.     float    f32[2];
  34. } av_alias av_alias64;
  35.  
  36. typedef union {
  37.     uint32_t u32;
  38.     uint16_t u16[2];
  39.     uint8_t  u8 [4];
  40.     float    f32;
  41. } av_alias av_alias32;
  42.  
  43. typedef union {
  44.     uint16_t u16;
  45.     uint8_t  u8 [2];
  46. } av_alias av_alias16;
  47.  
  48. /*
  49.  * Arch-specific headers can provide any combination of
  50.  * AV_[RW][BLN](16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros.
  51.  * Preprocessor symbols must be defined, even if these are implemented
  52.  * as inline functions.
  53.  *
  54.  * R/W means read/write, B/L/N means big/little/native endianness.
  55.  * The following macros require aligned access, compared to their
  56.  * unaligned variants: AV_(COPY|SWAP|ZERO)(64|128), AV_[RW]N[8-64]A.
  57.  * Incorrect usage may range from abysmal performance to crash
  58.  * depending on the platform.
  59.  *
  60.  * The unaligned variants are AV_[RW][BLN][8-64] and AV_COPY*U.
  61.  */
  62.  
  63. #ifdef HAVE_AV_CONFIG_H
  64.  
  65. #include "config.h"
  66.  
  67. #if   ARCH_ARM
  68. #   include "arm/intreadwrite.h"
  69. #elif ARCH_AVR32
  70. #   include "avr32/intreadwrite.h"
  71. #elif ARCH_MIPS
  72. #   include "mips/intreadwrite.h"
  73. #elif ARCH_PPC
  74. #   include "ppc/intreadwrite.h"
  75. #elif ARCH_TOMI
  76. #   include "tomi/intreadwrite.h"
  77. #elif ARCH_X86
  78. #   include "x86/intreadwrite.h"
  79. #endif
  80.  
  81. #endif /* HAVE_AV_CONFIG_H */
  82.  
  83. /*
  84.  * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers.
  85.  */
  86.  
  87. #if AV_HAVE_BIGENDIAN
  88.  
  89. #   if    defined(AV_RN16) && !defined(AV_RB16)
  90. #       define AV_RB16(p) AV_RN16(p)
  91. #   elif !defined(AV_RN16) &&  defined(AV_RB16)
  92. #       define AV_RN16(p) AV_RB16(p)
  93. #   endif
  94.  
  95. #   if    defined(AV_WN16) && !defined(AV_WB16)
  96. #       define AV_WB16(p, v) AV_WN16(p, v)
  97. #   elif !defined(AV_WN16) &&  defined(AV_WB16)
  98. #       define AV_WN16(p, v) AV_WB16(p, v)
  99. #   endif
  100.  
  101. #   if    defined(AV_RN24) && !defined(AV_RB24)
  102. #       define AV_RB24(p) AV_RN24(p)
  103. #   elif !defined(AV_RN24) &&  defined(AV_RB24)
  104. #       define AV_RN24(p) AV_RB24(p)
  105. #   endif
  106.  
  107. #   if    defined(AV_WN24) && !defined(AV_WB24)
  108. #       define AV_WB24(p, v) AV_WN24(p, v)
  109. #   elif !defined(AV_WN24) &&  defined(AV_WB24)
  110. #       define AV_WN24(p, v) AV_WB24(p, v)
  111. #   endif
  112.  
  113. #   if    defined(AV_RN32) && !defined(AV_RB32)
  114. #       define AV_RB32(p) AV_RN32(p)
  115. #   elif !defined(AV_RN32) &&  defined(AV_RB32)
  116. #       define AV_RN32(p) AV_RB32(p)
  117. #   endif
  118.  
  119. #   if    defined(AV_WN32) && !defined(AV_WB32)
  120. #       define AV_WB32(p, v) AV_WN32(p, v)
  121. #   elif !defined(AV_WN32) &&  defined(AV_WB32)
  122. #       define AV_WN32(p, v) AV_WB32(p, v)
  123. #   endif
  124.  
  125. #   if    defined(AV_RN48) && !defined(AV_RB48)
  126. #       define AV_RB48(p) AV_RN48(p)
  127. #   elif !defined(AV_RN48) &&  defined(AV_RB48)
  128. #       define AV_RN48(p) AV_RB48(p)
  129. #   endif
  130.  
  131. #   if    defined(AV_WN48) && !defined(AV_WB48)
  132. #       define AV_WB48(p, v) AV_WN48(p, v)
  133. #   elif !defined(AV_WN48) &&  defined(AV_WB48)
  134. #       define AV_WN48(p, v) AV_WB48(p, v)
  135. #   endif
  136.  
  137. #   if    defined(AV_RN64) && !defined(AV_RB64)
  138. #       define AV_RB64(p) AV_RN64(p)
  139. #   elif !defined(AV_RN64) &&  defined(AV_RB64)
  140. #       define AV_RN64(p) AV_RB64(p)
  141. #   endif
  142.  
  143. #   if    defined(AV_WN64) && !defined(AV_WB64)
  144. #       define AV_WB64(p, v) AV_WN64(p, v)
  145. #   elif !defined(AV_WN64) &&  defined(AV_WB64)
  146. #       define AV_WN64(p, v) AV_WB64(p, v)
  147. #   endif
  148.  
  149. #else /* AV_HAVE_BIGENDIAN */
  150.  
  151. #   if    defined(AV_RN16) && !defined(AV_RL16)
  152. #       define AV_RL16(p) AV_RN16(p)
  153. #   elif !defined(AV_RN16) &&  defined(AV_RL16)
  154. #       define AV_RN16(p) AV_RL16(p)
  155. #   endif
  156.  
  157. #   if    defined(AV_WN16) && !defined(AV_WL16)
  158. #       define AV_WL16(p, v) AV_WN16(p, v)
  159. #   elif !defined(AV_WN16) &&  defined(AV_WL16)
  160. #       define AV_WN16(p, v) AV_WL16(p, v)
  161. #   endif
  162.  
  163. #   if    defined(AV_RN24) && !defined(AV_RL24)
  164. #       define AV_RL24(p) AV_RN24(p)
  165. #   elif !defined(AV_RN24) &&  defined(AV_RL24)
  166. #       define AV_RN24(p) AV_RL24(p)
  167. #   endif
  168.  
  169. #   if    defined(AV_WN24) && !defined(AV_WL24)
  170. #       define AV_WL24(p, v) AV_WN24(p, v)
  171. #   elif !defined(AV_WN24) &&  defined(AV_WL24)
  172. #       define AV_WN24(p, v) AV_WL24(p, v)
  173. #   endif
  174.  
  175. #   if    defined(AV_RN32) && !defined(AV_RL32)
  176. #       define AV_RL32(p) AV_RN32(p)
  177. #   elif !defined(AV_RN32) &&  defined(AV_RL32)
  178. #       define AV_RN32(p) AV_RL32(p)
  179. #   endif
  180.  
  181. #   if    defined(AV_WN32) && !defined(AV_WL32)
  182. #       define AV_WL32(p, v) AV_WN32(p, v)
  183. #   elif !defined(AV_WN32) &&  defined(AV_WL32)
  184. #       define AV_WN32(p, v) AV_WL32(p, v)
  185. #   endif
  186.  
  187. #   if    defined(AV_RN48) && !defined(AV_RL48)
  188. #       define AV_RL48(p) AV_RN48(p)
  189. #   elif !defined(AV_RN48) &&  defined(AV_RL48)
  190. #       define AV_RN48(p) AV_RL48(p)
  191. #   endif
  192.  
  193. #   if    defined(AV_WN48) && !defined(AV_WL48)
  194. #       define AV_WL48(p, v) AV_WN48(p, v)
  195. #   elif !defined(AV_WN48) &&  defined(AV_WL48)
  196. #       define AV_WN48(p, v) AV_WL48(p, v)
  197. #   endif
  198.  
  199. #   if    defined(AV_RN64) && !defined(AV_RL64)
  200. #       define AV_RL64(p) AV_RN64(p)
  201. #   elif !defined(AV_RN64) &&  defined(AV_RL64)
  202. #       define AV_RN64(p) AV_RL64(p)
  203. #   endif
  204.  
  205. #   if    defined(AV_WN64) && !defined(AV_WL64)
  206. #       define AV_WL64(p, v) AV_WN64(p, v)
  207. #   elif !defined(AV_WN64) &&  defined(AV_WL64)
  208. #       define AV_WN64(p, v) AV_WL64(p, v)
  209. #   endif
  210.  
  211. #endif /* !AV_HAVE_BIGENDIAN */
  212.  
  213. /*
  214.  * Define AV_[RW]N helper macros to simplify definitions not provided
  215.  * by per-arch headers.
  216.  */
  217.  
  218. #if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__)
  219.  
  220. union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
  221. union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
  222. union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
  223.  
  224. #   define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
  225. #   define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
  226.  
  227. #elif defined(__DECC)
  228.  
  229. #   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
  230. #   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
  231.  
  232. #elif AV_HAVE_FAST_UNALIGNED
  233.  
  234. #   define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
  235. #   define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v))
  236.  
  237. #else
  238.  
  239. #ifndef AV_RB16
  240. #   define AV_RB16(x)                           \
  241.     ((((const uint8_t*)(x))[0] << 8) |          \
  242.       ((const uint8_t*)(x))[1])
  243. #endif
  244. #ifndef AV_WB16
  245. #   define AV_WB16(p, darg) do {                \
  246.         unsigned d = (darg);                    \
  247.         ((uint8_t*)(p))[1] = (d);               \
  248.         ((uint8_t*)(p))[0] = (d)>>8;            \
  249.     } while(0)
  250. #endif
  251.  
  252. #ifndef AV_RL16
  253. #   define AV_RL16(x)                           \
  254.     ((((const uint8_t*)(x))[1] << 8) |          \
  255.       ((const uint8_t*)(x))[0])
  256. #endif
  257. #ifndef AV_WL16
  258. #   define AV_WL16(p, darg) do {                \
  259.         unsigned d = (darg);                    \
  260.         ((uint8_t*)(p))[0] = (d);               \
  261.         ((uint8_t*)(p))[1] = (d)>>8;            \
  262.     } while(0)
  263. #endif
  264.  
  265. #ifndef AV_RB32
  266. #   define AV_RB32(x)                                \
  267.     (((uint32_t)((const uint8_t*)(x))[0] << 24) |    \
  268.                (((const uint8_t*)(x))[1] << 16) |    \
  269.                (((const uint8_t*)(x))[2] <<  8) |    \
  270.                 ((const uint8_t*)(x))[3])
  271. #endif
  272. #ifndef AV_WB32
  273. #   define AV_WB32(p, darg) do {                \
  274.         unsigned d = (darg);                    \
  275.         ((uint8_t*)(p))[3] = (d);               \
  276.         ((uint8_t*)(p))[2] = (d)>>8;            \
  277.         ((uint8_t*)(p))[1] = (d)>>16;           \
  278.         ((uint8_t*)(p))[0] = (d)>>24;           \
  279.     } while(0)
  280. #endif
  281.  
  282. #ifndef AV_RL32
  283. #   define AV_RL32(x)                                \
  284.     (((uint32_t)((const uint8_t*)(x))[3] << 24) |    \
  285.                (((const uint8_t*)(x))[2] << 16) |    \
  286.                (((const uint8_t*)(x))[1] <<  8) |    \
  287.                 ((const uint8_t*)(x))[0])
  288. #endif
  289. #ifndef AV_WL32
  290. #   define AV_WL32(p, darg) do {                \
  291.         unsigned d = (darg);                    \
  292.         ((uint8_t*)(p))[0] = (d);               \
  293.         ((uint8_t*)(p))[1] = (d)>>8;            \
  294.         ((uint8_t*)(p))[2] = (d)>>16;           \
  295.         ((uint8_t*)(p))[3] = (d)>>24;           \
  296.     } while(0)
  297. #endif
  298.  
  299. #ifndef AV_RB64
  300. #   define AV_RB64(x)                                   \
  301.     (((uint64_t)((const uint8_t*)(x))[0] << 56) |       \
  302.      ((uint64_t)((const uint8_t*)(x))[1] << 48) |       \
  303.      ((uint64_t)((const uint8_t*)(x))[2] << 40) |       \
  304.      ((uint64_t)((const uint8_t*)(x))[3] << 32) |       \
  305.      ((uint64_t)((const uint8_t*)(x))[4] << 24) |       \
  306.      ((uint64_t)((const uint8_t*)(x))[5] << 16) |       \
  307.      ((uint64_t)((const uint8_t*)(x))[6] <<  8) |       \
  308.       (uint64_t)((const uint8_t*)(x))[7])
  309. #endif
  310. #ifndef AV_WB64
  311. #   define AV_WB64(p, darg) do {                \
  312.         uint64_t d = (darg);                    \
  313.         ((uint8_t*)(p))[7] = (d);               \
  314.         ((uint8_t*)(p))[6] = (d)>>8;            \
  315.         ((uint8_t*)(p))[5] = (d)>>16;           \
  316.         ((uint8_t*)(p))[4] = (d)>>24;           \
  317.         ((uint8_t*)(p))[3] = (d)>>32;           \
  318.         ((uint8_t*)(p))[2] = (d)>>40;           \
  319.         ((uint8_t*)(p))[1] = (d)>>48;           \
  320.         ((uint8_t*)(p))[0] = (d)>>56;           \
  321.     } while(0)
  322. #endif
  323.  
  324. #ifndef AV_RL64
  325. #   define AV_RL64(x)                                   \
  326.     (((uint64_t)((const uint8_t*)(x))[7] << 56) |       \
  327.      ((uint64_t)((const uint8_t*)(x))[6] << 48) |       \
  328.      ((uint64_t)((const uint8_t*)(x))[5] << 40) |       \
  329.      ((uint64_t)((const uint8_t*)(x))[4] << 32) |       \
  330.      ((uint64_t)((const uint8_t*)(x))[3] << 24) |       \
  331.      ((uint64_t)((const uint8_t*)(x))[2] << 16) |       \
  332.      ((uint64_t)((const uint8_t*)(x))[1] <<  8) |       \
  333.       (uint64_t)((const uint8_t*)(x))[0])
  334. #endif
  335. #ifndef AV_WL64
  336. #   define AV_WL64(p, darg) do {                \
  337.         uint64_t d = (darg);                    \
  338.         ((uint8_t*)(p))[0] = (d);               \
  339.         ((uint8_t*)(p))[1] = (d)>>8;            \
  340.         ((uint8_t*)(p))[2] = (d)>>16;           \
  341.         ((uint8_t*)(p))[3] = (d)>>24;           \
  342.         ((uint8_t*)(p))[4] = (d)>>32;           \
  343.         ((uint8_t*)(p))[5] = (d)>>40;           \
  344.         ((uint8_t*)(p))[6] = (d)>>48;           \
  345.         ((uint8_t*)(p))[7] = (d)>>56;           \
  346.     } while(0)
  347. #endif
  348.  
  349. #if AV_HAVE_BIGENDIAN
  350. #   define AV_RN(s, p)    AV_RB##s(p)
  351. #   define AV_WN(s, p, v) AV_WB##s(p, v)
  352. #else
  353. #   define AV_RN(s, p)    AV_RL##s(p)
  354. #   define AV_WN(s, p, v) AV_WL##s(p, v)
  355. #endif
  356.  
  357. #endif /* HAVE_FAST_UNALIGNED */
  358.  
  359. #ifndef AV_RN16
  360. #   define AV_RN16(p) AV_RN(16, p)
  361. #endif
  362.  
  363. #ifndef AV_RN32
  364. #   define AV_RN32(p) AV_RN(32, p)
  365. #endif
  366.  
  367. #ifndef AV_RN64
  368. #   define AV_RN64(p) AV_RN(64, p)
  369. #endif
  370.  
  371. #ifndef AV_WN16
  372. #   define AV_WN16(p, v) AV_WN(16, p, v)
  373. #endif
  374.  
  375. #ifndef AV_WN32
  376. #   define AV_WN32(p, v) AV_WN(32, p, v)
  377. #endif
  378.  
  379. #ifndef AV_WN64
  380. #   define AV_WN64(p, v) AV_WN(64, p, v)
  381. #endif
  382.  
  383. #if AV_HAVE_BIGENDIAN
  384. #   define AV_RB(s, p)    AV_RN##s(p)
  385. #   define AV_WB(s, p, v) AV_WN##s(p, v)
  386. #   define AV_RL(s, p)    av_bswap##s(AV_RN##s(p))
  387. #   define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v))
  388. #else
  389. #   define AV_RB(s, p)    av_bswap##s(AV_RN##s(p))
  390. #   define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v))
  391. #   define AV_RL(s, p)    AV_RN##s(p)
  392. #   define AV_WL(s, p, v) AV_WN##s(p, v)
  393. #endif
  394.  
  395. #define AV_RB8(x)     (((const uint8_t*)(x))[0])
  396. #define AV_WB8(p, d)  do { ((uint8_t*)(p))[0] = (d); } while(0)
  397.  
  398. #define AV_RL8(x)     AV_RB8(x)
  399. #define AV_WL8(p, d)  AV_WB8(p, d)
  400.  
  401. #ifndef AV_RB16
  402. #   define AV_RB16(p)    AV_RB(16, p)
  403. #endif
  404. #ifndef AV_WB16
  405. #   define AV_WB16(p, v) AV_WB(16, p, v)
  406. #endif
  407.  
  408. #ifndef AV_RL16
  409. #   define AV_RL16(p)    AV_RL(16, p)
  410. #endif
  411. #ifndef AV_WL16
  412. #   define AV_WL16(p, v) AV_WL(16, p, v)
  413. #endif
  414.  
  415. #ifndef AV_RB32
  416. #   define AV_RB32(p)    AV_RB(32, p)
  417. #endif
  418. #ifndef AV_WB32
  419. #   define AV_WB32(p, v) AV_WB(32, p, v)
  420. #endif
  421.  
  422. #ifndef AV_RL32
  423. #   define AV_RL32(p)    AV_RL(32, p)
  424. #endif
  425. #ifndef AV_WL32
  426. #   define AV_WL32(p, v) AV_WL(32, p, v)
  427. #endif
  428.  
  429. #ifndef AV_RB64
  430. #   define AV_RB64(p)    AV_RB(64, p)
  431. #endif
  432. #ifndef AV_WB64
  433. #   define AV_WB64(p, v) AV_WB(64, p, v)
  434. #endif
  435.  
  436. #ifndef AV_RL64
  437. #   define AV_RL64(p)    AV_RL(64, p)
  438. #endif
  439. #ifndef AV_WL64
  440. #   define AV_WL64(p, v) AV_WL(64, p, v)
  441. #endif
  442.  
  443. #ifndef AV_RB24
  444. #   define AV_RB24(x)                           \
  445.     ((((const uint8_t*)(x))[0] << 16) |         \
  446.      (((const uint8_t*)(x))[1] <<  8) |         \
  447.       ((const uint8_t*)(x))[2])
  448. #endif
  449. #ifndef AV_WB24
  450. #   define AV_WB24(p, d) do {                   \
  451.         ((uint8_t*)(p))[2] = (d);               \
  452.         ((uint8_t*)(p))[1] = (d)>>8;            \
  453.         ((uint8_t*)(p))[0] = (d)>>16;           \
  454.     } while(0)
  455. #endif
  456.  
  457. #ifndef AV_RL24
  458. #   define AV_RL24(x)                           \
  459.     ((((const uint8_t*)(x))[2] << 16) |         \
  460.      (((const uint8_t*)(x))[1] <<  8) |         \
  461.       ((const uint8_t*)(x))[0])
  462. #endif
  463. #ifndef AV_WL24
  464. #   define AV_WL24(p, d) do {                   \
  465.         ((uint8_t*)(p))[0] = (d);               \
  466.         ((uint8_t*)(p))[1] = (d)>>8;            \
  467.         ((uint8_t*)(p))[2] = (d)>>16;           \
  468.     } while(0)
  469. #endif
  470.  
  471. #ifndef AV_RB48
  472. #   define AV_RB48(x)                                     \
  473.     (((uint64_t)((const uint8_t*)(x))[0] << 40) |         \
  474.      ((uint64_t)((const uint8_t*)(x))[1] << 32) |         \
  475.      ((uint64_t)((const uint8_t*)(x))[2] << 24) |         \
  476.      ((uint64_t)((const uint8_t*)(x))[3] << 16) |         \
  477.      ((uint64_t)((const uint8_t*)(x))[4] <<  8) |         \
  478.       (uint64_t)((const uint8_t*)(x))[5])
  479. #endif
  480. #ifndef AV_WB48
  481. #   define AV_WB48(p, darg) do {                \
  482.         uint64_t d = (darg);                    \
  483.         ((uint8_t*)(p))[5] = (d);               \
  484.         ((uint8_t*)(p))[4] = (d)>>8;            \
  485.         ((uint8_t*)(p))[3] = (d)>>16;           \
  486.         ((uint8_t*)(p))[2] = (d)>>24;           \
  487.         ((uint8_t*)(p))[1] = (d)>>32;           \
  488.         ((uint8_t*)(p))[0] = (d)>>40;           \
  489.     } while(0)
  490. #endif
  491.  
  492. #ifndef AV_RL48
  493. #   define AV_RL48(x)                                     \
  494.     (((uint64_t)((const uint8_t*)(x))[5] << 40) |         \
  495.      ((uint64_t)((const uint8_t*)(x))[4] << 32) |         \
  496.      ((uint64_t)((const uint8_t*)(x))[3] << 24) |         \
  497.      ((uint64_t)((const uint8_t*)(x))[2] << 16) |         \
  498.      ((uint64_t)((const uint8_t*)(x))[1] <<  8) |         \
  499.       (uint64_t)((const uint8_t*)(x))[0])
  500. #endif
  501. #ifndef AV_WL48
  502. #   define AV_WL48(p, darg) do {                \
  503.         uint64_t d = (darg);                    \
  504.         ((uint8_t*)(p))[0] = (d);               \
  505.         ((uint8_t*)(p))[1] = (d)>>8;            \
  506.         ((uint8_t*)(p))[2] = (d)>>16;           \
  507.         ((uint8_t*)(p))[3] = (d)>>24;           \
  508.         ((uint8_t*)(p))[4] = (d)>>32;           \
  509.         ((uint8_t*)(p))[5] = (d)>>40;           \
  510.     } while(0)
  511. #endif
  512.  
  513. /*
  514.  * The AV_[RW]NA macros access naturally aligned data
  515.  * in a type-safe way.
  516.  */
  517.  
  518. #define AV_RNA(s, p)    (((const av_alias##s*)(p))->u##s)
  519. #define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v))
  520.  
  521. #ifndef AV_RN16A
  522. #   define AV_RN16A(p) AV_RNA(16, p)
  523. #endif
  524.  
  525. #ifndef AV_RN32A
  526. #   define AV_RN32A(p) AV_RNA(32, p)
  527. #endif
  528.  
  529. #ifndef AV_RN64A
  530. #   define AV_RN64A(p) AV_RNA(64, p)
  531. #endif
  532.  
  533. #ifndef AV_WN16A
  534. #   define AV_WN16A(p, v) AV_WNA(16, p, v)
  535. #endif
  536.  
  537. #ifndef AV_WN32A
  538. #   define AV_WN32A(p, v) AV_WNA(32, p, v)
  539. #endif
  540.  
  541. #ifndef AV_WN64A
  542. #   define AV_WN64A(p, v) AV_WNA(64, p, v)
  543. #endif
  544.  
  545. /*
  546.  * The AV_COPYxxU macros are suitable for copying data to/from unaligned
  547.  * memory locations.
  548.  */
  549.  
  550. #define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s));
  551.  
  552. #ifndef AV_COPY16U
  553. #   define AV_COPY16U(d, s) AV_COPYU(16, d, s)
  554. #endif
  555.  
  556. #ifndef AV_COPY32U
  557. #   define AV_COPY32U(d, s) AV_COPYU(32, d, s)
  558. #endif
  559.  
  560. #ifndef AV_COPY64U
  561. #   define AV_COPY64U(d, s) AV_COPYU(64, d, s)
  562. #endif
  563.  
  564. #ifndef AV_COPY128U
  565. #   define AV_COPY128U(d, s)                                    \
  566.     do {                                                        \
  567.         AV_COPY64U(d, s);                                       \
  568.         AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8);     \
  569.     } while(0)
  570. #endif
  571.  
  572. /* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
  573.  * naturally aligned. They may be implemented using MMX,
  574.  * so emms_c() must be called before using any float code
  575.  * afterwards.
  576.  */
  577.  
  578. #define AV_COPY(n, d, s) \
  579.     (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n)
  580.  
  581. #ifndef AV_COPY16
  582. #   define AV_COPY16(d, s) AV_COPY(16, d, s)
  583. #endif
  584.  
  585. #ifndef AV_COPY32
  586. #   define AV_COPY32(d, s) AV_COPY(32, d, s)
  587. #endif
  588.  
  589. #ifndef AV_COPY64
  590. #   define AV_COPY64(d, s) AV_COPY(64, d, s)
  591. #endif
  592.  
  593. #ifndef AV_COPY128
  594. #   define AV_COPY128(d, s)                    \
  595.     do {                                       \
  596.         AV_COPY64(d, s);                       \
  597.         AV_COPY64((char*)(d)+8, (char*)(s)+8); \
  598.     } while(0)
  599. #endif
  600.  
  601. #define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b))
  602.  
  603. #ifndef AV_SWAP64
  604. #   define AV_SWAP64(a, b) AV_SWAP(64, a, b)
  605. #endif
  606.  
  607. #define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0)
  608.  
  609. #ifndef AV_ZERO16
  610. #   define AV_ZERO16(d) AV_ZERO(16, d)
  611. #endif
  612.  
  613. #ifndef AV_ZERO32
  614. #   define AV_ZERO32(d) AV_ZERO(32, d)
  615. #endif
  616.  
  617. #ifndef AV_ZERO64
  618. #   define AV_ZERO64(d) AV_ZERO(64, d)
  619. #endif
  620.  
  621. #ifndef AV_ZERO128
  622. #   define AV_ZERO128(d)         \
  623.     do {                         \
  624.         AV_ZERO64(d);            \
  625.         AV_ZERO64((char*)(d)+8); \
  626.     } while(0)
  627. #endif
  628.  
  629. #endif /* AVUTIL_INTREADWRITE_H */
  630.