[libav.git] / libavutil / intreadwrite.h

/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVUTIL_INTREADWRITE_H
#define AVUTIL_INTREADWRITE_H

#include <stdint.h>
#include "config.h"
#include "bswap.h"

/*
 * Arch-specific headers can provide any combination of
 * AV_[RW][BLN](16|24|32|64) macros.  Preprocessor symbols must be
 * defined, even if these are implemented as inline functions.
 */

#if   ARCH_ARM
#   include "arm/intreadwrite.h"
#elif ARCH_MIPS
#   include "mips/intreadwrite.h"
#elif ARCH_PPC
#   include "ppc/intreadwrite.h"
#endif

/*
 * Define AV_[RW]N helper macros to simplify definitions not provided
 * by per-arch headers.
 */

#if   HAVE_ATTRIBUTE_PACKED

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_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_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
#   define AV_WN(s, p, v) *((__unaligned uint##s##_t*)(p)) = (v)

#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

#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) | \
                     ((uint64_t)((const uint8_t*)(x))[3] << 32) | \
                     ((uint64_t)((const uint8_t*)(x))[4] << 24) | \
                     ((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;  \
                    ((uint8_t*)(p))[5] = (d)>>16; \
                    ((uint8_t*)(p))[4] = (d)>>24; \
                    ((uint8_t*)(p))[3] = (d)>>32; \
                    ((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) | \
                     ((uint64_t)((const uint8_t*)(x))[4] << 32) | \
                     ((uint64_t)((const uint8_t*)(x))[3] << 24) | \
                     ((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;  \
                    ((uint8_t*)(p))[2] = (d)>>16; \
                    ((uint8_t*)(p))[3] = (d)>>24; \
                    ((uint8_t*)(p))[4] = (d)>>32; \
                    ((uint8_t*)(p))[5] = (d)>>40; \
                    ((uint8_t*)(p))[6] = (d)>>48; \
                    ((uint8_t*)(p))[7] = (d)>>56; } while(0)
#endif

#if HAVE_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

#if HAVE_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

#ifndef AV_RB24
#define AV_RB24(x)  ((((const uint8_t*)(x))[0] << 16) | \
                     (((const uint8_t*)(x))[1] <<  8) | \
                      ((const uint8_t*)(x))[2])
#endif
#ifndef AV_WB24
#define AV_WB24(p, d) do { \
                    ((uint8_t*)(p))[2] = (d); \
                    ((uint8_t*)(p))[1] = (d)>>8; \
                    ((uint8_t*)(p))[0] = (d)>>16; } while(0)
#endif

#ifndef AV_RL24
#define AV_RL24(x)  ((((const uint8_t*)(x))[2] << 16) | \
                     (((const uint8_t*)(x))[1] <<  8) | \
                      ((const uint8_t*)(x))[0])
#endif
#ifndef AV_WL24
#define AV_WL24(p, d) do { \
                    ((uint8_t*)(p))[0] = (d); \
                    ((uint8_t*)(p))[1] = (d)>>8; \
                    ((uint8_t*)(p))[2] = (d)>>16; } while(0)
#endif

#endif /* AVUTIL_INTREADWRITE_H */
Commit	Line	Data
f5a90186 DB	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
98790382 SS	19	#ifndef AVUTIL_INTREADWRITE_H
98790382 SS	20	#define AVUTIL_INTREADWRITE_H
cf1e119b	21
99545457	22	#include <stdint.h>
a087028a	23	#include "config.h"
c08be350	24	#include "bswap.h"
99545457	25
a6783b89 MR	26	/*
a6783b89 MR	27	* Arch-specific headers can provide any combination of
57c36bdc	28	* AV_[RW][BLN](16\|24\|32\|64) macros. Preprocessor symbols must be
a6783b89 MR	29	* defined, even if these are implemented as inline functions.
	30	*/
	31
3c55ce03 MR	32	#if ARCH_ARM
3c55ce03 MR	33	# include "arm/intreadwrite.h"
530456bf MR	34	#elif ARCH_MIPS
530456bf MR	35	# include "mips/intreadwrite.h"
9f5ff83f MR	36	#elif ARCH_PPC
9f5ff83f MR	37	# include "ppc/intreadwrite.h"
3c55ce03	38	#endif
a6783b89 MR	39
	40	/*
	41	* Define AV_[RW]N helper macros to simplify definitions not provided
	42	* by per-arch headers.
	43	*/
	44
e7ea5e3d	45	#if HAVE_ATTRIBUTE_PACKED
cf1e119b RD	46
	47	struct unaligned_64 { uint64_t l; } __attribute__((packed));
	48	struct unaligned_32 { uint32_t l; } __attribute__((packed));
	49	struct unaligned_16 { uint16_t l; } __attribute__((packed));
	50
a6783b89 MR	51	# define AV_RN(s, p) (((const struct unaligned_##s *) (p))->l)
a6783b89 MR	52	# define AV_WN(s, p, v) (((struct unaligned_##s *) (p))->l) = (v)
cf1e119b	53
b7b38fb2 MR	54	#elif defined(__DECC)
b7b38fb2 MR	55
a6783b89 MR	56	# define AV_RN(s, p) (((const __unaligned uint##s##_t)(p)))
a6783b89 MR	57	# define AV_WN(s, p, v) ((__unaligned uint##s##_t)(p)) = (v)
fbbea48e	58
a6783b89	59	#elif HAVE_FAST_UNALIGNED
fbbea48e	60
a6783b89 MR	61	# define AV_RN(s, p) (((const uint##s##_t)(p)))
a6783b89 MR	62	# define AV_WN(s, p, v) ((uint##s##_t)(p)) = (v)
fbbea48e	63
a6783b89	64	#else
fbbea48e	65
a6783b89 MR	66	#ifndef AV_RB16
	67	#define AV_RB16(x) ((((const uint8_t*)(x))[0] << 8) \| \
	68	((const uint8_t*)(x))[1])
	69	#endif
	70	#ifndef AV_WB16
803ca89c	71	#define AV_WB16(p, d) do { \
7d4495da	72	((uint8_t*)(p))[1] = (d); \
803ca89c	73	((uint8_t*)(p))[0] = (d)>>8; } while(0)
a6783b89	74	#endif
a3550abd	75
a6783b89	76	#ifndef AV_RL16
ff794171 MN	77	#define AV_RL16(x) ((((const uint8_t*)(x))[1] << 8) \| \
ff794171 MN	78	((const uint8_t*)(x))[0])
a6783b89 MR	79	#endif
a6783b89 MR	80	#ifndef AV_WL16
803ca89c	81	#define AV_WL16(p, d) do { \
85b1a722	82	((uint8_t*)(p))[0] = (d); \
803ca89c	83	((uint8_t*)(p))[1] = (d)>>8; } while(0)
a6783b89	84	#endif
7b829d2a	85
a6783b89	86	#ifndef AV_RB32
ff794171 MN	87	#define AV_RB32(x) ((((const uint8_t*)(x))[0] << 24) \| \
	88	(((const uint8_t*)(x))[1] << 16) \| \
	89	(((const uint8_t*)(x))[2] << 8) \| \
	90	((const uint8_t*)(x))[3])
a6783b89 MR	91	#endif
a6783b89 MR	92	#ifndef AV_WB32
803ca89c	93	#define AV_WB32(p, d) do { \
7d4495da MN	94	((uint8_t*)(p))[3] = (d); \
	95	((uint8_t*)(p))[2] = (d)>>8; \
	96	((uint8_t*)(p))[1] = (d)>>16; \
803ca89c	97	((uint8_t*)(p))[0] = (d)>>24; } while(0)
a6783b89	98	#endif
a3550abd	99
a6783b89	100	#ifndef AV_RL32
ff794171 MN	101	#define AV_RL32(x) ((((const uint8_t*)(x))[3] << 24) \| \
	102	(((const uint8_t*)(x))[2] << 16) \| \
	103	(((const uint8_t*)(x))[1] << 8) \| \
	104	((const uint8_t*)(x))[0])
a6783b89 MR	105	#endif
a6783b89 MR	106	#ifndef AV_WL32
803ca89c	107	#define AV_WL32(p, d) do { \
7d4495da MN	108	((uint8_t*)(p))[0] = (d); \
	109	((uint8_t*)(p))[1] = (d)>>8; \
	110	((uint8_t*)(p))[2] = (d)>>16; \
803ca89c	111	((uint8_t*)(p))[3] = (d)>>24; } while(0)
a6783b89	112	#endif
9e010b41	113
a6783b89	114	#ifndef AV_RB64
ff794171 MN	115	#define AV_RB64(x) (((uint64_t)((const uint8_t*)(x))[0] << 56) \| \
	116	((uint64_t)((const uint8_t*)(x))[1] << 48) \| \
	117	((uint64_t)((const uint8_t*)(x))[2] << 40) \| \
	118	((uint64_t)((const uint8_t*)(x))[3] << 32) \| \
	119	((uint64_t)((const uint8_t*)(x))[4] << 24) \| \
	120	((uint64_t)((const uint8_t*)(x))[5] << 16) \| \
	121	((uint64_t)((const uint8_t*)(x))[6] << 8) \| \
	122	(uint64_t)((const uint8_t*)(x))[7])
a6783b89 MR	123	#endif
a6783b89 MR	124	#ifndef AV_WB64
803ca89c	125	#define AV_WB64(p, d) do { \
9e010b41 IP	126	((uint8_t*)(p))[7] = (d); \
	127	((uint8_t*)(p))[6] = (d)>>8; \
	128	((uint8_t*)(p))[5] = (d)>>16; \
	129	((uint8_t*)(p))[4] = (d)>>24; \
	130	((uint8_t*)(p))[3] = (d)>>32; \
	131	((uint8_t*)(p))[2] = (d)>>40; \
	132	((uint8_t*)(p))[1] = (d)>>48; \
803ca89c	133	((uint8_t*)(p))[0] = (d)>>56; } while(0)
a6783b89	134	#endif
9e010b41	135
a6783b89	136	#ifndef AV_RL64
ff794171 MN	137	#define AV_RL64(x) (((uint64_t)((const uint8_t*)(x))[7] << 56) \| \
	138	((uint64_t)((const uint8_t*)(x))[6] << 48) \| \
	139	((uint64_t)((const uint8_t*)(x))[5] << 40) \| \
	140	((uint64_t)((const uint8_t*)(x))[4] << 32) \| \
	141	((uint64_t)((const uint8_t*)(x))[3] << 24) \| \
	142	((uint64_t)((const uint8_t*)(x))[2] << 16) \| \
	143	((uint64_t)((const uint8_t*)(x))[1] << 8) \| \
	144	(uint64_t)((const uint8_t*)(x))[0])
a6783b89 MR	145	#endif
a6783b89 MR	146	#ifndef AV_WL64
803ca89c	147	#define AV_WL64(p, d) do { \
9e010b41 IP	148	((uint8_t*)(p))[0] = (d); \
	149	((uint8_t*)(p))[1] = (d)>>8; \
	150	((uint8_t*)(p))[2] = (d)>>16; \
	151	((uint8_t*)(p))[3] = (d)>>24; \
	152	((uint8_t*)(p))[4] = (d)>>32; \
	153	((uint8_t*)(p))[5] = (d)>>40; \
	154	((uint8_t*)(p))[6] = (d)>>48; \
803ca89c	155	((uint8_t*)(p))[7] = (d)>>56; } while(0)
a6783b89 MR	156	#endif
a6783b89 MR	157
63613fe6	158	#if HAVE_BIGENDIAN
a6783b89 MR	159	# define AV_RN(s, p) AV_RB##s(p)
	160	# define AV_WN(s, p, v) AV_WB##s(p, v)
	161	#else
	162	# define AV_RN(s, p) AV_RL##s(p)
	163	# define AV_WN(s, p, v) AV_WL##s(p, v)
	164	#endif
	165
	166	#endif /* HAVE_FAST_UNALIGNED */
	167
	168	#ifndef AV_RN16
	169	# define AV_RN16(p) AV_RN(16, p)
	170	#endif
	171
	172	#ifndef AV_RN32
	173	# define AV_RN32(p) AV_RN(32, p)
	174	#endif
	175
	176	#ifndef AV_RN64
	177	# define AV_RN64(p) AV_RN(64, p)
	178	#endif
	179
	180	#ifndef AV_WN16
	181	# define AV_WN16(p, v) AV_WN(16, p, v)
	182	#endif
	183
	184	#ifndef AV_WN32
	185	# define AV_WN32(p, v) AV_WN(32, p, v)
	186	#endif
	187
	188	#ifndef AV_WN64
	189	# define AV_WN64(p, v) AV_WN(64, p, v)
	190	#endif
	191
63613fe6	192	#if HAVE_BIGENDIAN
a6783b89 MR	193	# define AV_RB(s, p) AV_RN(s, p)
	194	# define AV_WB(s, p, v) AV_WN(s, p, v)
	195	# define AV_RL(s, p) bswap_##s(AV_RN(s, p))
	196	# define AV_WL(s, p, v) AV_WN(s, p, bswap_##s(v))
	197	#else
	198	# define AV_RB(s, p) bswap_##s(AV_RN(s, p))
	199	# define AV_WB(s, p, v) AV_WN(s, p, bswap_##s(v))
	200	# define AV_RL(s, p) AV_RN(s, p)
	201	# define AV_WL(s, p, v) AV_WN(s, p, v)
	202	#endif
	203
	204	#define AV_RB8(x) (((const uint8_t*)(x))[0])
	205	#define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0)
	206
	207	#define AV_RL8(x) AV_RB8(x)
	208	#define AV_WL8(p, d) AV_WB8(p, d)
	209
	210	#ifndef AV_RB16
	211	# define AV_RB16(p) AV_RB(16, p)
	212	#endif
	213	#ifndef AV_WB16
	214	# define AV_WB16(p, v) AV_WB(16, p, v)
	215	#endif
	216
	217	#ifndef AV_RL16
	218	# define AV_RL16(p) AV_RL(16, p)
	219	#endif
	220	#ifndef AV_WL16
	221	# define AV_WL16(p, v) AV_WL(16, p, v)
	222	#endif
	223
	224	#ifndef AV_RB32
	225	# define AV_RB32(p) AV_RB(32, p)
	226	#endif
	227	#ifndef AV_WB32
	228	# define AV_WB32(p, v) AV_WB(32, p, v)
	229	#endif
	230
	231	#ifndef AV_RL32
	232	# define AV_RL32(p) AV_RL(32, p)
	233	#endif
	234	#ifndef AV_WL32
	235	# define AV_WL32(p, v) AV_WL(32, p, v)
	236	#endif
	237
	238	#ifndef AV_RB64
	239	# define AV_RB64(p) AV_RB(64, p)
	240	#endif
	241	#ifndef AV_WB64
	242	# define AV_WB64(p, v) AV_WB(64, p, v)
	243	#endif
	244
	245	#ifndef AV_RL64
	246	# define AV_RL64(p) AV_RL(64, p)
	247	#endif
	248	#ifndef AV_WL64
	249	# define AV_WL64(p, v) AV_WL(64, p, v)
	250	#endif
fbbea48e	251
57c36bdc	252	#ifndef AV_RB24
fbbea48e MR	253	#define AV_RB24(x) ((((const uint8_t*)(x))[0] << 16) \| \
	254	(((const uint8_t*)(x))[1] << 8) \| \
	255	((const uint8_t*)(x))[2])
57c36bdc MR	256	#endif
57c36bdc MR	257	#ifndef AV_WB24
fbbea48e MR	258	#define AV_WB24(p, d) do { \
	259	((uint8_t*)(p))[2] = (d); \
	260	((uint8_t*)(p))[1] = (d)>>8; \
	261	((uint8_t*)(p))[0] = (d)>>16; } while(0)
57c36bdc	262	#endif
fbbea48e	263
57c36bdc	264	#ifndef AV_RL24
fbbea48e MR	265	#define AV_RL24(x) ((((const uint8_t*)(x))[2] << 16) \| \
	266	(((const uint8_t*)(x))[1] << 8) \| \
	267	((const uint8_t*)(x))[0])
57c36bdc MR	268	#endif
57c36bdc MR	269	#ifndef AV_WL24
fbbea48e MR	270	#define AV_WL24(p, d) do { \
	271	((uint8_t*)(p))[0] = (d); \
	272	((uint8_t*)(p))[1] = (d)>>8; \
	273	((uint8_t*)(p))[2] = (d)>>16; } while(0)
57c36bdc	274	#endif
9e010b41	275
98790382	276	#endif /* AVUTIL_INTREADWRITE_H */