common.h 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560
  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 sat(a + sat(2*b)) 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. * Subtract two signed 32-bit values with saturation.
  241. *
  242. * @param a one value
  243. * @param b another value
  244. * @return difference with signed saturation
  245. */
  246. static av_always_inline int av_sat_sub32_c(int a, int b)
  247. {
  248. return av_clipl_int32((int64_t)a - b);
  249. }
  250. /**
  251. * Subtract a doubled value from another value with saturation at both stages.
  252. *
  253. * @param a first value
  254. * @param b value doubled and subtracted from a
  255. * @return difference sat(a - sat(2*b)) with signed saturation
  256. */
  257. static av_always_inline int av_sat_dsub32_c(int a, int b)
  258. {
  259. return av_sat_sub32(a, av_sat_add32(b, b));
  260. }
  261. /**
  262. * Clip a float value into the amin-amax range.
  263. * @param a value to clip
  264. * @param amin minimum value of the clip range
  265. * @param amax maximum value of the clip range
  266. * @return clipped value
  267. */
  268. static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
  269. {
  270. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  271. if (amin > amax) abort();
  272. #endif
  273. if (a < amin) return amin;
  274. else if (a > amax) return amax;
  275. else return a;
  276. }
  277. /**
  278. * Clip a double value into the amin-amax range.
  279. * @param a value to clip
  280. * @param amin minimum value of the clip range
  281. * @param amax maximum value of the clip range
  282. * @return clipped value
  283. */
  284. static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
  285. {
  286. #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
  287. if (amin > amax) abort();
  288. #endif
  289. if (a < amin) return amin;
  290. else if (a > amax) return amax;
  291. else return a;
  292. }
  293. /** Compute ceil(log2(x)).
  294. * @param x value used to compute ceil(log2(x))
  295. * @return computed ceiling of log2(x)
  296. */
  297. static av_always_inline av_const int av_ceil_log2_c(int x)
  298. {
  299. return av_log2((x - 1) << 1);
  300. }
  301. /**
  302. * Count number of bits set to one in x
  303. * @param x value to count bits of
  304. * @return the number of bits set to one in x
  305. */
  306. static av_always_inline av_const int av_popcount_c(uint32_t x)
  307. {
  308. x -= (x >> 1) & 0x55555555;
  309. x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
  310. x = (x + (x >> 4)) & 0x0F0F0F0F;
  311. x += x >> 8;
  312. return (x + (x >> 16)) & 0x3F;
  313. }
  314. /**
  315. * Count number of bits set to one in x
  316. * @param x value to count bits of
  317. * @return the number of bits set to one in x
  318. */
  319. static av_always_inline av_const int av_popcount64_c(uint64_t x)
  320. {
  321. return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
  322. }
  323. static av_always_inline av_const int av_parity_c(uint32_t v)
  324. {
  325. return av_popcount(v) & 1;
  326. }
  327. #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
  328. #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
  329. /**
  330. * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
  331. *
  332. * @param val Output value, must be an lvalue of type uint32_t.
  333. * @param GET_BYTE Expression reading one byte from the input.
  334. * Evaluated up to 7 times (4 for the currently
  335. * assigned Unicode range). With a memory buffer
  336. * input, this could be *ptr++.
  337. * @param ERROR Expression to be evaluated on invalid input,
  338. * typically a goto statement.
  339. *
  340. * @warning ERROR should not contain a loop control statement which
  341. * could interact with the internal while loop, and should force an
  342. * exit from the macro code (e.g. through a goto or a return) in order
  343. * to prevent undefined results.
  344. */
  345. #define GET_UTF8(val, GET_BYTE, ERROR)\
  346. val= (GET_BYTE);\
  347. {\
  348. uint32_t top = (val & 128) >> 1;\
  349. if ((val & 0xc0) == 0x80 || val >= 0xFE)\
  350. ERROR\
  351. while (val & top) {\
  352. int tmp= (GET_BYTE) - 128;\
  353. if(tmp>>6)\
  354. ERROR\
  355. val= (val<<6) + tmp;\
  356. top <<= 5;\
  357. }\
  358. val &= (top << 1) - 1;\
  359. }
  360. /**
  361. * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
  362. *
  363. * @param val Output value, must be an lvalue of type uint32_t.
  364. * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
  365. * to native byte order. Evaluated one or two times.
  366. * @param ERROR Expression to be evaluated on invalid input,
  367. * typically a goto statement.
  368. */
  369. #define GET_UTF16(val, GET_16BIT, ERROR)\
  370. val = GET_16BIT;\
  371. {\
  372. unsigned int hi = val - 0xD800;\
  373. if (hi < 0x800) {\
  374. val = GET_16BIT - 0xDC00;\
  375. if (val > 0x3FFU || hi > 0x3FFU)\
  376. ERROR\
  377. val += (hi<<10) + 0x10000;\
  378. }\
  379. }\
  380. /**
  381. * @def PUT_UTF8(val, tmp, PUT_BYTE)
  382. * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
  383. * @param val is an input-only argument and should be of type uint32_t. It holds
  384. * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
  385. * val is given as a function it is executed only once.
  386. * @param tmp is a temporary variable and should be of type uint8_t. It
  387. * represents an intermediate value during conversion that is to be
  388. * output by PUT_BYTE.
  389. * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
  390. * It could be a function or a statement, and uses tmp as the input byte.
  391. * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
  392. * executed up to 4 times for values in the valid UTF-8 range and up to
  393. * 7 times in the general case, depending on the length of the converted
  394. * Unicode character.
  395. */
  396. #define PUT_UTF8(val, tmp, PUT_BYTE)\
  397. {\
  398. int bytes, shift;\
  399. uint32_t in = val;\
  400. if (in < 0x80) {\
  401. tmp = in;\
  402. PUT_BYTE\
  403. } else {\
  404. bytes = (av_log2(in) + 4) / 5;\
  405. shift = (bytes - 1) * 6;\
  406. tmp = (256 - (256 >> bytes)) | (in >> shift);\
  407. PUT_BYTE\
  408. while (shift >= 6) {\
  409. shift -= 6;\
  410. tmp = 0x80 | ((in >> shift) & 0x3f);\
  411. PUT_BYTE\
  412. }\
  413. }\
  414. }
  415. /**
  416. * @def PUT_UTF16(val, tmp, PUT_16BIT)
  417. * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
  418. * @param val is an input-only argument and should be of type uint32_t. It holds
  419. * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
  420. * val is given as a function it is executed only once.
  421. * @param tmp is a temporary variable and should be of type uint16_t. It
  422. * represents an intermediate value during conversion that is to be
  423. * output by PUT_16BIT.
  424. * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
  425. * in desired endianness. It could be a function or a statement, and uses tmp
  426. * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;"
  427. * PUT_BYTE will be executed 1 or 2 times depending on input character.
  428. */
  429. #define PUT_UTF16(val, tmp, PUT_16BIT)\
  430. {\
  431. uint32_t in = val;\
  432. if (in < 0x10000) {\
  433. tmp = in;\
  434. PUT_16BIT\
  435. } else {\
  436. tmp = 0xD800 | ((in - 0x10000) >> 10);\
  437. PUT_16BIT\
  438. tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
  439. PUT_16BIT\
  440. }\
  441. }\
  442. #include "mem.h"
  443. #ifdef HAVE_AV_CONFIG_H
  444. # include "internal.h"
  445. #endif /* HAVE_AV_CONFIG_H */
  446. #endif /* AVUTIL_COMMON_H */
  447. /*
  448. * The following definitions are outside the multiple inclusion guard
  449. * to ensure they are immediately available in intmath.h.
  450. */
  451. #ifndef av_ceil_log2
  452. # define av_ceil_log2 av_ceil_log2_c
  453. #endif
  454. #ifndef av_clip
  455. # define av_clip av_clip_c
  456. #endif
  457. #ifndef av_clip64
  458. # define av_clip64 av_clip64_c
  459. #endif
  460. #ifndef av_clip_uint8
  461. # define av_clip_uint8 av_clip_uint8_c
  462. #endif
  463. #ifndef av_clip_int8
  464. # define av_clip_int8 av_clip_int8_c
  465. #endif
  466. #ifndef av_clip_uint16
  467. # define av_clip_uint16 av_clip_uint16_c
  468. #endif
  469. #ifndef av_clip_int16
  470. # define av_clip_int16 av_clip_int16_c
  471. #endif
  472. #ifndef av_clipl_int32
  473. # define av_clipl_int32 av_clipl_int32_c
  474. #endif
  475. #ifndef av_clip_intp2
  476. # define av_clip_intp2 av_clip_intp2_c
  477. #endif
  478. #ifndef av_clip_uintp2
  479. # define av_clip_uintp2 av_clip_uintp2_c
  480. #endif
  481. #ifndef av_mod_uintp2
  482. # define av_mod_uintp2 av_mod_uintp2_c
  483. #endif
  484. #ifndef av_sat_add32
  485. # define av_sat_add32 av_sat_add32_c
  486. #endif
  487. #ifndef av_sat_dadd32
  488. # define av_sat_dadd32 av_sat_dadd32_c
  489. #endif
  490. #ifndef av_sat_sub32
  491. # define av_sat_sub32 av_sat_sub32_c
  492. #endif
  493. #ifndef av_sat_dsub32
  494. # define av_sat_dsub32 av_sat_dsub32_c
  495. #endif
  496. #ifndef av_clipf
  497. # define av_clipf av_clipf_c
  498. #endif
  499. #ifndef av_clipd
  500. # define av_clipd av_clipd_c
  501. #endif
  502. #ifndef av_popcount
  503. # define av_popcount av_popcount_c
  504. #endif
  505. #ifndef av_popcount64
  506. # define av_popcount64 av_popcount64_c
  507. #endif
  508. #ifndef av_parity
  509. # define av_parity av_parity_c
  510. #endif