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;
87 int64_t
a2 = (
a %
c *
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;
107 for (
i = 63;
i >= 0;
i--) {
137 int64_t
b = bq.
num * (int64_t)cq.
den;
138 int64_t
c = cq.
num * (int64_t)bq.
den;
149 int64_t
a = tb_a.
num * (int64_t)tb_b.
den;
150 int64_t
b = tb_b.
num * (int64_t)tb_a.
den;
152 return (ts_a*
a > ts_b*
b) - (ts_a*
a < ts_b*
b);
162 int64_t
c = (
a -
b) & (
mod - 1);
182 if (*last < 2*a - b || *last > 2*
b -
a)
185 this = av_clip64(*last,
a,
b);
198 m = inc_tb.
num * (int64_t)ts_tb.
den;
199 d = inc_tb.
den * (int64_t)ts_tb.
num;
201 if (m % d == 0 && ts <= INT64_MAX - m / d)
213 return av_sat_add64(
av_rescale_q(old + 1, inc_tb, ts_tb), ts - old_ts);
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 FFSWAP(type, a, b)
#define u(width, name, range_min, range_max)
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)
@ AV_ROUND_UP
Round toward +infinity.
AVInteger av_int2i(int64_t a)
Convert the given int64_t to an AVInteger.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
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)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Rational number (pair of numerator and denominator).
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
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
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
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define i(width, name, range_min, range_max)
@ AV_ROUND_DOWN
Round toward -infinity.
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.
AVInteger av_div_i(AVInteger a, AVInteger b)
Return a/b.
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
static double b0(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.