falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
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.
19914 Commits
32 Branches
293MB
Tree: 3bbc46102b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3bbc46102b'
${ noResults }
FFmpeg/libavutil/intreadwrite.h

269 lines
8.1KB
Raw Blame History 

  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 "config.h"

  24. #include "bswap.h"

  25. 

  26. /*

  27.  * Arch-specific headers can provide any combination of

  28.  * AV_[RW][BLN](16|32|64) macros.  Preprocessor symbols must be

  29.  * defined, even if these are implemented as inline functions.

  30.  */

  31. 

  32. #if   ARCH_ARM

  33. #   include "arm/intreadwrite.h"

  34. #elif ARCH_MIPS

  35. #   include "mips/intreadwrite.h"

  36. #elif ARCH_PPC

  37. #   include "ppc/intreadwrite.h"

  38. #endif

  39. 

  40. /*

  41.  * Define AV_[RW]N helper macros to simplify definitions not provided

  42.  * by per-arch headers.

  43.  */

  44. 

  45. #if   defined(__GNUC__)

  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. 

  51. #   define AV_RN(s, p) (((const struct unaligned_##s *) (p))->l)

  52. #   define AV_WN(s, p, v) (((struct unaligned_##s *) (p))->l) = (v)

  53. 

  54. #elif defined(__DECC)

  55. 

  56. #   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))

  57. #   define AV_WN(s, p, v) *((__unaligned uint##s##_t*)(p)) = (v)

  58. 

  59. #elif HAVE_FAST_UNALIGNED

  60. 

  61. #   define AV_RN(s, p) (*((const uint##s##_t*)(p)))

  62. #   define AV_WN(s, p, v) *((uint##s##_t*)(p)) = (v)

  63. 

  64. #else

  65. 

  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

  71. #define AV_WB16(p, d) do { \

  72.                     ((uint8_t*)(p))[1] = (d); \

  73.                     ((uint8_t*)(p))[0] = (d)>>8; } while(0)

  74. #endif

  75. 

  76. #ifndef AV_RL16

  77. #define AV_RL16(x)  ((((const uint8_t*)(x))[1] << 8) | \

  78.                       ((const uint8_t*)(x))[0])

  79. #endif

  80. #ifndef AV_WL16

  81. #define AV_WL16(p, d) do { \

  82.                     ((uint8_t*)(p))[0] = (d); \

  83.                     ((uint8_t*)(p))[1] = (d)>>8; } while(0)

  84. #endif

  85. 

  86. #ifndef AV_RB32

  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])

  91. #endif

  92. #ifndef AV_WB32

  93. #define AV_WB32(p, d) do { \

  94.                     ((uint8_t*)(p))[3] = (d); \

  95.                     ((uint8_t*)(p))[2] = (d)>>8; \

  96.                     ((uint8_t*)(p))[1] = (d)>>16; \

  97.                     ((uint8_t*)(p))[0] = (d)>>24; } while(0)

  98. #endif

  99. 

  100. #ifndef AV_RL32

  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])

  105. #endif

  106. #ifndef AV_WL32

  107. #define AV_WL32(p, d) do { \

  108.                     ((uint8_t*)(p))[0] = (d); \

  109.                     ((uint8_t*)(p))[1] = (d)>>8; \

  110.                     ((uint8_t*)(p))[2] = (d)>>16; \

  111.                     ((uint8_t*)(p))[3] = (d)>>24; } while(0)

  112. #endif

  113. 

  114. #ifndef AV_RB64

  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])

  123. #endif

  124. #ifndef AV_WB64

  125. #define AV_WB64(p, d) do { \

  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; \

  133.                     ((uint8_t*)(p))[0] = (d)>>56; } while(0)

  134. #endif

  135. 

  136. #ifndef AV_RL64

  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])

  145. #endif

  146. #ifndef AV_WL64

  147. #define AV_WL64(p, d) do { \

  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; \

  155.                     ((uint8_t*)(p))[7] = (d)>>56; } while(0)

  156. #endif

  157. 

  158. #ifdef WORDS_BIGENDIAN

  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. 

  192. #ifdef WORDS_BIGENDIAN

  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

  251. 

  252. #define AV_RB24(x)  ((((const uint8_t*)(x))[0] << 16) | \

  253.                      (((const uint8_t*)(x))[1] <<  8) | \

  254.                       ((const uint8_t*)(x))[2])

  255. #define AV_WB24(p, d) do { \

  256.                     ((uint8_t*)(p))[2] = (d); \

  257.                     ((uint8_t*)(p))[1] = (d)>>8; \

  258.                     ((uint8_t*)(p))[0] = (d)>>16; } while(0)

  259. 

  260. #define AV_RL24(x)  ((((const uint8_t*)(x))[2] << 16) | \

  261.                      (((const uint8_t*)(x))[1] <<  8) | \

  262.                       ((const uint8_t*)(x))[0])

  263. #define AV_WL24(p, d) do { \

  264.                     ((uint8_t*)(p))[0] = (d); \

  265.                     ((uint8_t*)(p))[1] = (d)>>8; \

  266.                     ((uint8_t*)(p))[2] = (d)>>16; } while(0)

  267. 

  268. #endif /* AVUTIL_INTREADWRITE_H */