common.h 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530
  1. /*
  2. * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
  3. *
  4. * This file is part of FFmpeg.
  5. *
  6. * FFmpeg is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2.1 of the License, or (at your option) any later version.
  10. *
  11. * FFmpeg is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with FFmpeg; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. */
  20. /**
  21. * @file
  22. * common internal and external API header
  23. */
  24. #ifndef AVUTIL_COMMON_H
  25. #define AVUTIL_COMMON_H
  26. #if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C)
  27. #error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS
  28. #endif
  29. #include <errno.h>
  30. #include <inttypes.h>
  31. #include <limits.h>
  32. #include <math.h>
  33. #include <stdint.h>
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37. #include "attributes.h"
  38. #include "macros.h"
  39. #include "version.h"
  40. #include "libavutil/avconfig.h"
  41. #if AV_HAVE_BIGENDIAN
  42. # define AV_NE(be, le) (be)
  43. #else
  44. # define AV_NE(be, le) (le)
  45. #endif
  46. //rounded division & shift
  47. #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
  48. /* assume b>0 */
  49. #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
  50. /* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */
  51. #define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
  52. : ((a) + (1<<(b)) - 1) >> (b))
  53. /* Backwards compat. */
  54. #define FF_CEIL_RSHIFT AV_CEIL_RSHIFT
  55. #define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
  56. #define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
  57. /**
  58. * Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they
  59. * are not representable as absolute values of their type. This is the same
  60. * as with *abs()
  61. * @see FFNABS()
  62. */
  63. #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
  64. #define FFSIGN(a) ((a) > 0 ? 1 : -1)
  65. /**
  66. * Negative Absolute value.
  67. * this works for all integers of all types.
  68. * As with many macros, this evaluates its argument twice, it thus must not have
  69. * a sideeffect, that is FFNABS(x++) has undefined behavior.
  70. */
  71. #define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
  72. /**
  73. * Comparator.
  74. * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
  75. * if x == y. This is useful for instance in a qsort comparator callback.
  76. * Furthermore, compilers are able to optimize this to branchless code, and
  77. * there is no risk of overflow with signed types.
  78. * As with many macros, this evaluates its argument multiple times, it thus
  79. * must not have a side-effect.
  80. */
  81. #define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
  82. #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
  83. #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
  84. #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
  85. #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
  86. #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
  87. #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
  88. /* misc math functions */
  89. #ifdef HAVE_AV_CONFIG_H
  90. # include "config.h"
  91. # include "intmath.h"
  92. #endif
  93. /* Pull in unguarded fallback defines at the end of this file. */
  94. #include "common.h"
  95. #ifndef av_log2
  96. av_const int av_log2(unsigned v);
  97. #endif
  98. #ifndef av_log2_16bit
  99. av_const int av_log2_16bit(unsigned v);
  100. #endif
  101. /**
  102. * Clip a signed integer value into the amin-amax range.
  103. * @param a value to clip
  104. * @param amin minimum value of the clip range
  105. * @param amax maximum value of the clip range
  106. * @return clipped value
  107. */
  108. static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
  109. {
  110. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  111. if (amin > amax) abort();
  112. #endif
  113. if (a < amin) return amin;
  114. else if (a > amax) return amax;
  115. else return a;
  116. }
  117. /**
  118. * Clip a signed 64bit integer value into the amin-amax range.
  119. * @param a value to clip
  120. * @param amin minimum value of the clip range
  121. * @param amax maximum value of the clip range
  122. * @return clipped value
  123. */
  124. static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
  125. {
  126. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  127. if (amin > amax) abort();
  128. #endif
  129. if (a < amin) return amin;
  130. else if (a > amax) return amax;
  131. else return a;
  132. }
  133. /**
  134. * Clip a signed integer value into the 0-255 range.
  135. * @param a value to clip
  136. * @return clipped value
  137. */
  138. static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
  139. {
  140. if (a&(~0xFF)) return (-a)>>31;
  141. else return a;
  142. }
  143. /**
  144. * Clip a signed integer value into the -128,127 range.
  145. * @param a value to clip
  146. * @return clipped value
  147. */
  148. static av_always_inline av_const int8_t av_clip_int8_c(int a)
  149. {
  150. if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
  151. else return a;
  152. }
  153. /**
  154. * Clip a signed integer value into the 0-65535 range.
  155. * @param a value to clip
  156. * @return clipped value
  157. */
  158. static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
  159. {
  160. if (a&(~0xFFFF)) return (-a)>>31;
  161. else return a;
  162. }
  163. /**
  164. * Clip a signed integer value into the -32768,32767 range.
  165. * @param a value to clip
  166. * @return clipped value
  167. */
  168. static av_always_inline av_const int16_t av_clip_int16_c(int a)
  169. {
  170. if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
  171. else return a;
  172. }
  173. /**
  174. * Clip a signed 64-bit integer value into the -2147483648,2147483647 range.
  175. * @param a value to clip
  176. * @return clipped value
  177. */
  178. static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
  179. {
  180. if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
  181. else return (int32_t)a;
  182. }
  183. /**
  184. * Clip a signed integer into the -(2^p),(2^p-1) range.
  185. * @param a value to clip
  186. * @param p bit position to clip at
  187. * @return clipped value
  188. */
  189. static av_always_inline av_const int av_clip_intp2_c(int a, int p)
  190. {
  191. if (((unsigned)a + (1 << p)) & ~((2 << p) - 1))
  192. return (a >> 31) ^ ((1 << p) - 1);
  193. else
  194. return a;
  195. }
  196. /**
  197. * Clip a signed integer to an unsigned power of two range.
  198. * @param a value to clip
  199. * @param p bit position to clip at
  200. * @return clipped value
  201. */
  202. static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
  203. {
  204. if (a & ~((1<<p) - 1)) return -a >> 31 & ((1<<p) - 1);
  205. else return a;
  206. }
  207. /**
  208. * Clear high bits from an unsigned integer starting with specific bit position
  209. * @param a value to clip
  210. * @param p bit position to clip at
  211. * @return clipped value
  212. */
  213. static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
  214. {
  215. return a & ((1 << p) - 1);
  216. }
  217. /**
  218. * Add two signed 32-bit values with saturation.
  219. *
  220. * @param a one value
  221. * @param b another value
  222. * @return sum with signed saturation
  223. */
  224. static av_always_inline int av_sat_add32_c(int a, int b)
  225. {
  226. return av_clipl_int32((int64_t)a + b);
  227. }
  228. /**
  229. * Add a doubled value to another value with saturation at both stages.
  230. *
  231. * @param a first value
  232. * @param b value doubled and added to a
  233. * @return sum with signed saturation
  234. */
  235. static av_always_inline int av_sat_dadd32_c(int a, int b)
  236. {
  237. return av_sat_add32(a, av_sat_add32(b, b));
  238. }
  239. /**
  240. * Clip a float value into the amin-amax range.
  241. * @param a value to clip
  242. * @param amin minimum value of the clip range
  243. * @param amax maximum value of the clip range
  244. * @return clipped value
  245. */
  246. static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
  247. {
  248. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  249. if (amin > amax) abort();
  250. #endif
  251. if (a < amin) return amin;
  252. else if (a > amax) return amax;
  253. else return a;
  254. }
  255. /**
  256. * Clip a double value into the amin-amax range.
  257. * @param a value to clip
  258. * @param amin minimum value of the clip range
  259. * @param amax maximum value of the clip range
  260. * @return clipped value
  261. */
  262. static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
  263. {
  264. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  265. if (amin > amax) abort();
  266. #endif
  267. if (a < amin) return amin;
  268. else if (a > amax) return amax;
  269. else return a;
  270. }
  271. /** Compute ceil(log2(x)).
  272. * @param x value used to compute ceil(log2(x))
  273. * @return computed ceiling of log2(x)
  274. */
  275. static av_always_inline av_const int av_ceil_log2_c(int x)
  276. {
  277. return av_log2((x - 1) << 1);
  278. }
  279. /**
  280. * Count number of bits set to one in x
  281. * @param x value to count bits of
  282. * @return the number of bits set to one in x
  283. */
  284. static av_always_inline av_const int av_popcount_c(uint32_t x)
  285. {
  286. x -= (x >> 1) & 0x55555555;
  287. x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
  288. x = (x + (x >> 4)) & 0x0F0F0F0F;
  289. x += x >> 8;
  290. return (x + (x >> 16)) & 0x3F;
  291. }
  292. /**
  293. * Count number of bits set to one in x
  294. * @param x value to count bits of
  295. * @return the number of bits set to one in x
  296. */
  297. static av_always_inline av_const int av_popcount64_c(uint64_t x)
  298. {
  299. return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
  300. }
  301. static av_always_inline av_const int av_parity_c(uint32_t v)
  302. {
  303. return av_popcount(v) & 1;
  304. }
  305. #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
  306. #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
  307. /**
  308. * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
  309. *
  310. * @param val Output value, must be an lvalue of type uint32_t.
  311. * @param GET_BYTE Expression reading one byte from the input.
  312. * Evaluated up to 7 times (4 for the currently
  313. * assigned Unicode range). With a memory buffer
  314. * input, this could be *ptr++.
  315. * @param ERROR Expression to be evaluated on invalid input,
  316. * typically a goto statement.
  317. *
  318. * @warning ERROR should not contain a loop control statement which
  319. * could interact with the internal while loop, and should force an
  320. * exit from the macro code (e.g. through a goto or a return) in order
  321. * to prevent undefined results.
  322. */
  323. #define GET_UTF8(val, GET_BYTE, ERROR)\
  324. val= (GET_BYTE);\
  325. {\
  326. uint32_t top = (val & 128) >> 1;\
  327. if ((val & 0xc0) == 0x80 || val >= 0xFE)\
  328. ERROR\
  329. while (val & top) {\
  330. int tmp= (GET_BYTE) - 128;\
  331. if(tmp>>6)\
  332. ERROR\
  333. val= (val<<6) + tmp;\
  334. top <<= 5;\
  335. }\
  336. val &= (top << 1) - 1;\
  337. }
  338. /**
  339. * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
  340. *
  341. * @param val Output value, must be an lvalue of type uint32_t.
  342. * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
  343. * to native byte order. Evaluated one or two times.
  344. * @param ERROR Expression to be evaluated on invalid input,
  345. * typically a goto statement.
  346. */
  347. #define GET_UTF16(val, GET_16BIT, ERROR)\
  348. val = GET_16BIT;\
  349. {\
  350. unsigned int hi = val - 0xD800;\
  351. if (hi < 0x800) {\
  352. val = GET_16BIT - 0xDC00;\
  353. if (val > 0x3FFU || hi > 0x3FFU)\
  354. ERROR\
  355. val += (hi<<10) + 0x10000;\
  356. }\
  357. }\
  358. /**
  359. * @def PUT_UTF8(val, tmp, PUT_BYTE)
  360. * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
  361. * @param val is an input-only argument and should be of type uint32_t. It holds
  362. * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
  363. * val is given as a function it is executed only once.
  364. * @param tmp is a temporary variable and should be of type uint8_t. It
  365. * represents an intermediate value during conversion that is to be
  366. * output by PUT_BYTE.
  367. * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
  368. * It could be a function or a statement, and uses tmp as the input byte.
  369. * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
  370. * executed up to 4 times for values in the valid UTF-8 range and up to
  371. * 7 times in the general case, depending on the length of the converted
  372. * Unicode character.
  373. */
  374. #define PUT_UTF8(val, tmp, PUT_BYTE)\
  375. {\
  376. int bytes, shift;\
  377. uint32_t in = val;\
  378. if (in < 0x80) {\
  379. tmp = in;\
  380. PUT_BYTE\
  381. } else {\
  382. bytes = (av_log2(in) + 4) / 5;\
  383. shift = (bytes - 1) * 6;\
  384. tmp = (256 - (256 >> bytes)) | (in >> shift);\
  385. PUT_BYTE\
  386. while (shift >= 6) {\
  387. shift -= 6;\
  388. tmp = 0x80 | ((in >> shift) & 0x3f);\
  389. PUT_BYTE\
  390. }\
  391. }\
  392. }
  393. /**
  394. * @def PUT_UTF16(val, tmp, PUT_16BIT)
  395. * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
  396. * @param val is an input-only argument and should be of type uint32_t. It holds
  397. * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
  398. * val is given as a function it is executed only once.
  399. * @param tmp is a temporary variable and should be of type uint16_t. It
  400. * represents an intermediate value during conversion that is to be
  401. * output by PUT_16BIT.
  402. * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
  403. * in desired endianness. It could be a function or a statement, and uses tmp
  404. * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;"
  405. * PUT_BYTE will be executed 1 or 2 times depending on input character.
  406. */
  407. #define PUT_UTF16(val, tmp, PUT_16BIT)\
  408. {\
  409. uint32_t in = val;\
  410. if (in < 0x10000) {\
  411. tmp = in;\
  412. PUT_16BIT\
  413. } else {\
  414. tmp = 0xD800 | ((in - 0x10000) >> 10);\
  415. PUT_16BIT\
  416. tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
  417. PUT_16BIT\
  418. }\
  419. }\
  420. #include "mem.h"
  421. #ifdef HAVE_AV_CONFIG_H
  422. # include "internal.h"
  423. #endif /* HAVE_AV_CONFIG_H */
  424. #endif /* AVUTIL_COMMON_H */
  425. /*
  426. * The following definitions are outside the multiple inclusion guard
  427. * to ensure they are immediately available in intmath.h.
  428. */
  429. #ifndef av_ceil_log2
  430. # define av_ceil_log2 av_ceil_log2_c
  431. #endif
  432. #ifndef av_clip
  433. # define av_clip av_clip_c
  434. #endif
  435. #ifndef av_clip64
  436. # define av_clip64 av_clip64_c
  437. #endif
  438. #ifndef av_clip_uint8
  439. # define av_clip_uint8 av_clip_uint8_c
  440. #endif
  441. #ifndef av_clip_int8
  442. # define av_clip_int8 av_clip_int8_c
  443. #endif
  444. #ifndef av_clip_uint16
  445. # define av_clip_uint16 av_clip_uint16_c
  446. #endif
  447. #ifndef av_clip_int16
  448. # define av_clip_int16 av_clip_int16_c
  449. #endif
  450. #ifndef av_clipl_int32
  451. # define av_clipl_int32 av_clipl_int32_c
  452. #endif
  453. #ifndef av_clip_intp2
  454. # define av_clip_intp2 av_clip_intp2_c
  455. #endif
  456. #ifndef av_clip_uintp2
  457. # define av_clip_uintp2 av_clip_uintp2_c
  458. #endif
  459. #ifndef av_mod_uintp2
  460. # define av_mod_uintp2 av_mod_uintp2_c
  461. #endif
  462. #ifndef av_sat_add32
  463. # define av_sat_add32 av_sat_add32_c
  464. #endif
  465. #ifndef av_sat_dadd32
  466. # define av_sat_dadd32 av_sat_dadd32_c
  467. #endif
  468. #ifndef av_clipf
  469. # define av_clipf av_clipf_c
  470. #endif
  471. #ifndef av_clipd
  472. # define av_clipd av_clipd_c
  473. #endif
  474. #ifndef av_popcount
  475. # define av_popcount av_popcount_c
  476. #endif
  477. #ifndef av_popcount64
  478. # define av_popcount64 av_popcount64_c
  479. #endif
  480. #ifndef av_parity
  481. # define av_parity av_parity_c
  482. #endif