common.h 16 KB

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