mathematics.h 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243
  1. /*
  2. * copyright (c) 2005-2012 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. * @addtogroup lavu_math
  23. * Mathematical utilities for working with timestamp and time base.
  24. */
  25. #ifndef AVUTIL_MATHEMATICS_H
  26. #define AVUTIL_MATHEMATICS_H
  27. #include <stdint.h>
  28. #include <math.h>
  29. #include "attributes.h"
  30. #include "rational.h"
  31. #include "intfloat.h"
  32. #ifndef M_E
  33. #define M_E 2.7182818284590452354 /* e */
  34. #endif
  35. #ifndef M_LN2
  36. #define M_LN2 0.69314718055994530942 /* log_e 2 */
  37. #endif
  38. #ifndef M_LN10
  39. #define M_LN10 2.30258509299404568402 /* log_e 10 */
  40. #endif
  41. #ifndef M_LOG2_10
  42. #define M_LOG2_10 3.32192809488736234787 /* log_2 10 */
  43. #endif
  44. #ifndef M_PHI
  45. #define M_PHI 1.61803398874989484820 /* phi / golden ratio */
  46. #endif
  47. #ifndef M_PI
  48. #define M_PI 3.14159265358979323846 /* pi */
  49. #endif
  50. #ifndef M_PI_2
  51. #define M_PI_2 1.57079632679489661923 /* pi/2 */
  52. #endif
  53. #ifndef M_SQRT1_2
  54. #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
  55. #endif
  56. #ifndef M_SQRT2
  57. #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
  58. #endif
  59. #ifndef NAN
  60. #define NAN av_int2float(0x7fc00000)
  61. #endif
  62. #ifndef INFINITY
  63. #define INFINITY av_int2float(0x7f800000)
  64. #endif
  65. /**
  66. * @addtogroup lavu_math
  67. *
  68. * @{
  69. */
  70. /**
  71. * Rounding methods.
  72. */
  73. enum AVRounding {
  74. AV_ROUND_ZERO = 0, ///< Round toward zero.
  75. AV_ROUND_INF = 1, ///< Round away from zero.
  76. AV_ROUND_DOWN = 2, ///< Round toward -infinity.
  77. AV_ROUND_UP = 3, ///< Round toward +infinity.
  78. AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
  79. /**
  80. * Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through
  81. * unchanged, avoiding special cases for #AV_NOPTS_VALUE.
  82. *
  83. * Unlike other values of the enumeration AVRounding, this value is a
  84. * bitmask that must be used in conjunction with another value of the
  85. * enumeration through a bitwise OR, in order to set behavior for normal
  86. * cases.
  87. *
  88. * @code{.c}
  89. * av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
  90. * // Rescaling 3:
  91. * // Calculating 3 * 1 / 2
  92. * // 3 / 2 is rounded up to 2
  93. * // => 2
  94. *
  95. * av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
  96. * // Rescaling AV_NOPTS_VALUE:
  97. * // AV_NOPTS_VALUE == INT64_MIN
  98. * // AV_NOPTS_VALUE is passed through
  99. * // => AV_NOPTS_VALUE
  100. * @endcode
  101. */
  102. AV_ROUND_PASS_MINMAX = 8192,
  103. };
  104. /**
  105. * Compute the greatest common divisor of two integer operands.
  106. *
  107. * @param a,b Operands
  108. * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
  109. * if a == 0 and b == 0, returns 0.
  110. */
  111. int64_t av_const av_gcd(int64_t a, int64_t b);
  112. /**
  113. * Rescale a 64-bit integer with rounding to nearest.
  114. *
  115. * The operation is mathematically equivalent to `a * b / c`, but writing that
  116. * directly can overflow.
  117. *
  118. * This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF.
  119. *
  120. * @see av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()
  121. */
  122. int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
  123. /**
  124. * Rescale a 64-bit integer with specified rounding.
  125. *
  126. * The operation is mathematically equivalent to `a * b / c`, but writing that
  127. * directly can overflow, and does not support different rounding methods.
  128. * If the result is not representable then INT64_MIN is returned.
  129. *
  130. * @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
  131. */
  132. int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;
  133. /**
  134. * Rescale a 64-bit integer by 2 rational numbers.
  135. *
  136. * The operation is mathematically equivalent to `a * bq / cq`.
  137. *
  138. * This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.
  139. *
  140. * @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()
  141. */
  142. int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
  143. /**
  144. * Rescale a 64-bit integer by 2 rational numbers with specified rounding.
  145. *
  146. * The operation is mathematically equivalent to `a * bq / cq`.
  147. *
  148. * @see av_rescale(), av_rescale_rnd(), av_rescale_q()
  149. */
  150. int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
  151. enum AVRounding rnd) av_const;
  152. /**
  153. * Compare two timestamps each in its own time base.
  154. *
  155. * @return One of the following values:
  156. * - -1 if `ts_a` is before `ts_b`
  157. * - 1 if `ts_a` is after `ts_b`
  158. * - 0 if they represent the same position
  159. *
  160. * @warning
  161. * The result of the function is undefined if one of the timestamps is outside
  162. * the `int64_t` range when represented in the other's timebase.
  163. */
  164. int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
  165. /**
  166. * Compare the remainders of two integer operands divided by a common divisor.
  167. *
  168. * In other words, compare the least significant `log2(mod)` bits of integers
  169. * `a` and `b`.
  170. *
  171. * @code{.c}
  172. * av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10 (0x1) < 0x02 % 0x10 (0x2)
  173. * av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
  174. * @endcode
  175. *
  176. * @param a,b Operands
  177. * @param mod Divisor; must be a power of 2
  178. * @return
  179. * - a negative value if `a % mod < b % mod`
  180. * - a positive value if `a % mod > b % mod`
  181. * - zero if `a % mod == b % mod`
  182. */
  183. int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
  184. /**
  185. * Rescale a timestamp while preserving known durations.
  186. *
  187. * This function is designed to be called per audio packet to scale the input
  188. * timestamp to a different time base. Compared to a simple av_rescale_q()
  189. * call, this function is robust against possible inconsistent frame durations.
  190. *
  191. * The `last` parameter is a state variable that must be preserved for all
  192. * subsequent calls for the same stream. For the first call, `*last` should be
  193. * initialized to #AV_NOPTS_VALUE.
  194. *
  195. * @param[in] in_tb Input time base
  196. * @param[in] in_ts Input timestamp
  197. * @param[in] fs_tb Duration time base; typically this is finer-grained
  198. * (greater) than `in_tb` and `out_tb`
  199. * @param[in] duration Duration till the next call to this function (i.e.
  200. * duration of the current packet/frame)
  201. * @param[in,out] last Pointer to a timestamp expressed in terms of
  202. * `fs_tb`, acting as a state variable
  203. * @param[in] out_tb Output timebase
  204. * @return Timestamp expressed in terms of `out_tb`
  205. *
  206. * @note In the context of this function, "duration" is in term of samples, not
  207. * seconds.
  208. */
  209. int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
  210. /**
  211. * Add a value to a timestamp.
  212. *
  213. * This function guarantees that when the same value is repeatly added that
  214. * no accumulation of rounding errors occurs.
  215. *
  216. * @param[in] ts Input timestamp
  217. * @param[in] ts_tb Input timestamp time base
  218. * @param[in] inc Value to be added
  219. * @param[in] inc_tb Time base of `inc`
  220. */
  221. int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
  222. /**
  223. * @}
  224. */
  225. #endif /* AVUTIL_MATHEMATICS_H */