Mercurial > libavutil.hg

changeset 727:98b64f65be0d libavutil

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Reorganise intreadwrite.h This changes intreadwrite.h to support per-arch implementations of the various macros allowing us to take advantage of special instructions or other properties the compiler does not know about.
author mru
date Sat, 18 Apr 2009 00:00:22 +0000
parents 5d344280a1f8
children 1fa3820b1a84
files intreadwrite.h
diffstat 1 files changed, 141 insertions(+), 72 deletions(-) [+]
line wrap: on
line diff
--- a/intreadwrite.h	Fri Apr 10 17:23:38 2009 +0000
+++ b/intreadwrite.h	Sat Apr 18 00:00:22 2009 +0000
@@ -23,119 +23,88 @@
 #include "config.h"
 #include "bswap.h"
 
-#ifdef __GNUC__
+/*
+ * Arch-specific headers can provide any combination of
+ * AV_[RW][BLN](16|32|64) macros.  Preprocessor symbols must be
+ * defined, even if these are implemented as inline functions.
+ */
+
+
+/*
+ * Define AV_[RW]N helper macros to simplify definitions not provided
+ * by per-arch headers.
+ */
+
+#if   defined(__GNUC__)
 
 struct unaligned_64 { uint64_t l; } __attribute__((packed));
 struct unaligned_32 { uint32_t l; } __attribute__((packed));
 struct unaligned_16 { uint16_t l; } __attribute__((packed));
 
-#define AV_RN16(a) (((const struct unaligned_16 *) (a))->l)
-#define AV_RN32(a) (((const struct unaligned_32 *) (a))->l)
-#define AV_RN64(a) (((const struct unaligned_64 *) (a))->l)
-
-#define AV_WN16(a, b) (((struct unaligned_16 *) (a))->l) = (b)
-#define AV_WN32(a, b) (((struct unaligned_32 *) (a))->l) = (b)
-#define AV_WN64(a, b) (((struct unaligned_64 *) (a))->l) = (b)
+#   define AV_RN(s, p) (((const struct unaligned_##s *) (p))->l)
+#   define AV_WN(s, p, v) (((struct unaligned_##s *) (p))->l) = (v)
 
 #elif defined(__DECC)
 
-#define AV_RN16(a) (*((const __unaligned uint16_t*)(a)))
-#define AV_RN32(a) (*((const __unaligned uint32_t*)(a)))
-#define AV_RN64(a) (*((const __unaligned uint64_t*)(a)))
+#   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
+#   define AV_WN(s, p, v) *((__unaligned uint##s##_t*)(p)) = (v)
 
-#define AV_WN16(a, b) *((__unaligned uint16_t*)(a)) = (b)
-#define AV_WN32(a, b) *((__unaligned uint32_t*)(a)) = (b)
-#define AV_WN64(a, b) *((__unaligned uint64_t*)(a)) = (b)
+#elif HAVE_FAST_UNALIGNED
+
+#   define AV_RN(s, p) (*((const uint##s##_t*)(p)))
+#   define AV_WN(s, p, v) *((uint##s##_t*)(p)) = (v)
 
 #else
 
-#define AV_RN16(a) (*((const uint16_t*)(a)))
-#define AV_RN32(a) (*((const uint32_t*)(a)))
-#define AV_RN64(a) (*((const uint64_t*)(a)))
-
-#define AV_WN16(a, b) *((uint16_t*)(a)) = (b)
-#define AV_WN32(a, b) *((uint32_t*)(a)) = (b)
-#define AV_WN64(a, b) *((uint64_t*)(a)) = (b)
-
-#endif /* !__GNUC__ */
-
-/* endian macros */
-#define AV_RB8(x)     (((const uint8_t*)(x))[0])
-#define AV_WB8(p, d)  do { ((uint8_t*)(p))[0] = (d); } while(0)
-
-#define AV_RL8(x)     AV_RB8(x)
-#define AV_WL8(p, d)  AV_WB8(p, d)
-
-#if HAVE_FAST_UNALIGNED
-# ifdef WORDS_BIGENDIAN
-#  define AV_RB16(x)    AV_RN16(x)
-#  define AV_WB16(p, d) AV_WN16(p, d)
-
-#  define AV_RL16(x)    bswap_16(AV_RN16(x))
-#  define AV_WL16(p, d) AV_WN16(p, bswap_16(d))
-
-#  define AV_RB32(x)    AV_RN32(x)
-#  define AV_WB32(p, d) AV_WN32(p, d)
-
-#  define AV_RL32(x)    bswap_32(AV_RN32(x))
-#  define AV_WL32(p, d) AV_WN32(p, bswap_32(d))
-
-#  define AV_RB64(x)    AV_RN64(x)
-#  define AV_WB64(p, d) AV_WN64(p, d)
-
-#  define AV_RL64(x)    bswap_64(AV_RN64(x))
-#  define AV_WL64(p, d) AV_WN64(p, bswap_64(d))
-# else /* WORDS_BIGENDIAN */
-#  define AV_RB16(x)    bswap_16(AV_RN16(x))
-#  define AV_WB16(p, d) AV_WN16(p, bswap_16(d))
-
-#  define AV_RL16(x)    AV_RN16(x)
-#  define AV_WL16(p, d) AV_WN16(p, d)
-
-#  define AV_RB32(x)    bswap_32(AV_RN32(x))
-#  define AV_WB32(p, d) AV_WN32(p, bswap_32(d))
-
-#  define AV_RL32(x)    AV_RN32(x)
-#  define AV_WL32(p, d) AV_WN32(p, d)
-
-#  define AV_RB64(x)    bswap_64(AV_RN64(x))
-#  define AV_WB64(p, d) AV_WN64(p, bswap_64(d))
-
-#  define AV_RL64(x)    AV_RN64(x)
-#  define AV_WL64(p, d) AV_WN64(p, d)
-# endif
-#else /* HAVE_FAST_UNALIGNED */
-#define AV_RB16(x)  ((((const uint8_t*)(x))[0] << 8) | ((const uint8_t*)(x))[1])
+#ifndef AV_RB16
+#define AV_RB16(x)  ((((const uint8_t*)(x))[0] << 8) | \
+                      ((const uint8_t*)(x))[1])
+#endif
+#ifndef AV_WB16
 #define AV_WB16(p, d) do { \
                     ((uint8_t*)(p))[1] = (d); \
                     ((uint8_t*)(p))[0] = (d)>>8; } while(0)
+#endif
 
+#ifndef AV_RL16
 #define AV_RL16(x)  ((((const uint8_t*)(x))[1] << 8) | \
                       ((const uint8_t*)(x))[0])
+#endif
+#ifndef AV_WL16
 #define AV_WL16(p, d) do { \
                     ((uint8_t*)(p))[0] = (d); \
                     ((uint8_t*)(p))[1] = (d)>>8; } while(0)
+#endif
 
+#ifndef AV_RB32
 #define AV_RB32(x)  ((((const uint8_t*)(x))[0] << 24) | \
                      (((const uint8_t*)(x))[1] << 16) | \
                      (((const uint8_t*)(x))[2] <<  8) | \
                       ((const uint8_t*)(x))[3])
+#endif
+#ifndef AV_WB32
 #define AV_WB32(p, d) do { \
                     ((uint8_t*)(p))[3] = (d); \
                     ((uint8_t*)(p))[2] = (d)>>8; \
                     ((uint8_t*)(p))[1] = (d)>>16; \
                     ((uint8_t*)(p))[0] = (d)>>24; } while(0)
+#endif
 
+#ifndef AV_RL32
 #define AV_RL32(x) ((((const uint8_t*)(x))[3] << 24) | \
                     (((const uint8_t*)(x))[2] << 16) | \
                     (((const uint8_t*)(x))[1] <<  8) | \
                      ((const uint8_t*)(x))[0])
+#endif
+#ifndef AV_WL32
 #define AV_WL32(p, d) do { \
                     ((uint8_t*)(p))[0] = (d); \
                     ((uint8_t*)(p))[1] = (d)>>8; \
                     ((uint8_t*)(p))[2] = (d)>>16; \
                     ((uint8_t*)(p))[3] = (d)>>24; } while(0)
+#endif
 
+#ifndef AV_RB64
 #define AV_RB64(x)  (((uint64_t)((const uint8_t*)(x))[0] << 56) | \
                      ((uint64_t)((const uint8_t*)(x))[1] << 48) | \
                      ((uint64_t)((const uint8_t*)(x))[2] << 40) | \
@@ -144,6 +113,8 @@
                      ((uint64_t)((const uint8_t*)(x))[5] << 16) | \
                      ((uint64_t)((const uint8_t*)(x))[6] <<  8) | \
                       (uint64_t)((const uint8_t*)(x))[7])
+#endif
+#ifndef AV_WB64
 #define AV_WB64(p, d) do { \
                     ((uint8_t*)(p))[7] = (d);     \
                     ((uint8_t*)(p))[6] = (d)>>8;  \
@@ -153,7 +124,9 @@
                     ((uint8_t*)(p))[2] = (d)>>40; \
                     ((uint8_t*)(p))[1] = (d)>>48; \
                     ((uint8_t*)(p))[0] = (d)>>56; } while(0)
+#endif
 
+#ifndef AV_RL64
 #define AV_RL64(x)  (((uint64_t)((const uint8_t*)(x))[7] << 56) | \
                      ((uint64_t)((const uint8_t*)(x))[6] << 48) | \
                      ((uint64_t)((const uint8_t*)(x))[5] << 40) | \
@@ -162,6 +135,8 @@
                      ((uint64_t)((const uint8_t*)(x))[2] << 16) | \
                      ((uint64_t)((const uint8_t*)(x))[1] <<  8) | \
                       (uint64_t)((const uint8_t*)(x))[0])
+#endif
+#ifndef AV_WL64
 #define AV_WL64(p, d) do { \
                     ((uint8_t*)(p))[0] = (d);     \
                     ((uint8_t*)(p))[1] = (d)>>8;  \
@@ -171,7 +146,101 @@
                     ((uint8_t*)(p))[5] = (d)>>40; \
                     ((uint8_t*)(p))[6] = (d)>>48; \
                     ((uint8_t*)(p))[7] = (d)>>56; } while(0)
-#endif  /* HAVE_FAST_UNALIGNED */
+#endif
+
+#ifdef WORDS_BIGENDIAN
+#   define AV_RN(s, p)    AV_RB##s(p)
+#   define AV_WN(s, p, v) AV_WB##s(p, v)
+#else
+#   define AV_RN(s, p)    AV_RL##s(p)
+#   define AV_WN(s, p, v) AV_WL##s(p, v)
+#endif
+
+#endif /* HAVE_FAST_UNALIGNED */
+
+#ifndef AV_RN16
+#   define AV_RN16(p) AV_RN(16, p)
+#endif
+
+#ifndef AV_RN32
+#   define AV_RN32(p) AV_RN(32, p)
+#endif
+
+#ifndef AV_RN64
+#   define AV_RN64(p) AV_RN(64, p)
+#endif
+
+#ifndef AV_WN16
+#   define AV_WN16(p, v) AV_WN(16, p, v)
+#endif
+
+#ifndef AV_WN32
+#   define AV_WN32(p, v) AV_WN(32, p, v)
+#endif
+
+#ifndef AV_WN64
+#   define AV_WN64(p, v) AV_WN(64, p, v)
+#endif
+
+#ifdef WORDS_BIGENDIAN
+#   define AV_RB(s, p)    AV_RN(s, p)
+#   define AV_WB(s, p, v) AV_WN(s, p, v)
+#   define AV_RL(s, p)    bswap_##s(AV_RN(s, p))
+#   define AV_WL(s, p, v) AV_WN(s, p, bswap_##s(v))
+#else
+#   define AV_RB(s, p)    bswap_##s(AV_RN(s, p))
+#   define AV_WB(s, p, v) AV_WN(s, p, bswap_##s(v))
+#   define AV_RL(s, p)    AV_RN(s, p)
+#   define AV_WL(s, p, v) AV_WN(s, p, v)
+#endif
+
+#define AV_RB8(x)     (((const uint8_t*)(x))[0])
+#define AV_WB8(p, d)  do { ((uint8_t*)(p))[0] = (d); } while(0)
+
+#define AV_RL8(x)     AV_RB8(x)
+#define AV_WL8(p, d)  AV_WB8(p, d)
+
+#ifndef AV_RB16
+#   define AV_RB16(p)    AV_RB(16, p)
+#endif
+#ifndef AV_WB16
+#   define AV_WB16(p, v) AV_WB(16, p, v)
+#endif
+
+#ifndef AV_RL16
+#   define AV_RL16(p)    AV_RL(16, p)
+#endif
+#ifndef AV_WL16
+#   define AV_WL16(p, v) AV_WL(16, p, v)
+#endif
+
+#ifndef AV_RB32
+#   define AV_RB32(p)    AV_RB(32, p)
+#endif
+#ifndef AV_WB32
+#   define AV_WB32(p, v) AV_WB(32, p, v)
+#endif
+
+#ifndef AV_RL32
+#   define AV_RL32(p)    AV_RL(32, p)
+#endif
+#ifndef AV_WL32
+#   define AV_WL32(p, v) AV_WL(32, p, v)
+#endif
+
+#ifndef AV_RB64
+#   define AV_RB64(p)    AV_RB(64, p)
+#endif
+#ifndef AV_WB64
+#   define AV_WB64(p, v) AV_WB(64, p, v)
+#endif
+
+#ifndef AV_RL64
+#   define AV_RL64(p)    AV_RL(64, p)
+#endif
+#ifndef AV_WL64
+#   define AV_WL64(p, v) AV_WL(64, p, v)
+#endif
 
 #define AV_RB24(x)  ((((const uint8_t*)(x))[0] << 16) | \
                      (((const uint8_t*)(x))[1] <<  8) | \