Go to the documentation of this file.
55 return (uint64_t)
u << k;
69 if (
a == INT64_MIN ||
a == INT64_MAX)
82 if (
b <= INT_MAX &&
c <= INT_MAX) {
84 return (
a *
b +
r) /
c;
88 if (ad >= INT32_MAX &&
b && ad > (INT64_MAX -
a2) /
b)
94 uint64_t
a0 =
a & 0xFFFFFFFF;
95 uint64_t
a1 =
a >> 32;
96 uint64_t
b0 =
b & 0xFFFFFFFF;
97 uint64_t
b1 =
b >> 32;
99 uint64_t t1a = t1 << 32;
103 a1 =
a1 *
b1 + (t1 >> 32) + (
a0 < t1a);
107 for (
i = 63;
i >= 0;
i--) {
152 return (ts_a*
a > ts_b*
b) - (ts_a*
a < ts_b*
b);
182 if (*last < 2*a - b || *last > 2*
b -
a)
201 if (m % d == 0 && ts <= INT64_MAX - m / d)
220 for (
i =
size-2;
i >= 0; --
i) {
261 static const double p1[] = {
262 -2.2335582639474375249e+15,
263 -5.5050369673018427753e+14,
264 -3.2940087627407749166e+13,
265 -8.4925101247114157499e+11,
266 -1.1912746104985237192e+10,
267 -1.0313066708737980747e+08,
268 -5.9545626019847898221e+05,
269 -2.4125195876041896775e+03,
270 -7.0935347449210549190e+00,
271 -1.5453977791786851041e-02,
272 -2.5172644670688975051e-05,
273 -3.0517226450451067446e-08,
274 -2.6843448573468483278e-11,
275 -1.5982226675653184646e-14,
276 -5.2487866627945699800e-18,
278 static const double q1[] = {
279 -2.2335582639474375245e+15,
280 7.8858692566751002988e+12,
281 -1.2207067397808979846e+10,
282 1.0377081058062166144e+07,
283 -4.8527560179962773045e+03,
286 static const double p2[] = {
287 -2.2210262233306573296e-04,
288 1.3067392038106924055e-02,
289 -4.4700805721174453923e-01,
290 5.5674518371240761397e+00,
291 -2.3517945679239481621e+01,
292 3.1611322818701131207e+01,
293 -9.6090021968656180000e+00,
295 static const double q2[] = {
296 -5.5194330231005480228e-04,
297 3.2547697594819615062e-02,
298 -1.1151759188741312645e+00,
299 1.3982595353892851542e+01,
300 -6.0228002066743340583e+01,
301 8.5539563258012929600e+01,
302 -3.1446690275135491500e+01,
314 y = 1 / x - 1.0 / 15;
@ AV_ROUND_UP
Round toward +infinity.
static const uint8_t q1[256]
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
Add a value to a timestamp.
#define u(width, name, range_min, range_max)
double av_bessel_i0(double x)
0th order modified bessel function of the first kind.
AVRounding
Rounding methods.
int64_t av_i2int(AVInteger a)
Convert the given AVInteger to an int64_t.
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
static double b1(void *priv, double x, double y)
static double a2(void *priv, double x, double y)
#define FF_ARRAY_ELEMS(a)
AVInteger av_int2i(int64_t a)
Convert the given int64_t to an AVInteger.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static double eval_poly(const double *coeff, int size, double x)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb)
Rescale a timestamp while preserving known durations.
AVInteger av_add_i(AVInteger a, AVInteger b)
static __device__ float fabs(float a)
Rational number (pair of numerator and denominator).
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static int inc(int num, int period)
@ AV_ROUND_DOWN
Round toward -infinity.
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
#define AV_NOPTS_VALUE
Undefined timestamp value.
AVInteger av_mul_i(AVInteger a, AVInteger b)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static double a0(void *priv, double x, double y)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define i(width, name, range_min, range_max)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
static int mod(int a, int b)
Modulo operation with only positive remainders.
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare the remainders of two integer operands divided by a common divisor.
#define FFSWAP(type, a, b)
AVInteger av_div_i(AVInteger a, AVInteger b)
Return a/b.
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
static const int factor[16]
static const double coeff[2][5]
static double b0(void *priv, double x, double y)
static double a1(void *priv, double x, double y)
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.