=================================================================
AVRational结构体和其相关的函数分析：
FFmpeg有理数相关的源码：AVRational结构体和其相关的函数分析
FFmpeg源码：av_rescale_rnd、av_rescale_q_rnd、av_rescale_q、av_add_stable函数分析
=================================================================
一、av_rescale_rnd函数
（一）av_rescale_rnd函数的声明
av_rescale_rnd函数声明在FFmpeg源码（本文演示用的FFmpeg源码版本为7.0.1）的头文件libavutil/mathematics.h中：
cpp
/**
* Rounding methods.
*/
enum AVRounding {
AV_ROUND_ZERO = 0, ///< Round toward zero.
AV_ROUND_INF = 1, ///< Round away from zero.
AV_ROUND_DOWN = 2, ///< Round toward -infinity.
AV_ROUND_UP = 3, ///< Round toward +infinity.
AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
/**
* Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through
* unchanged, avoiding special cases for #AV_NOPTS_VALUE.
*
* Unlike other values of the enumeration AVRounding, this value is a
* bitmask that must be used in conjunction with another value of the
* enumeration through a bitwise OR, in order to set behavior for normal
* cases.
*
* @code{.c}
* av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
* // Rescaling 3:
* // Calculating 3 * 1 / 2
* // 3 / 2 is rounded up to 2
* // => 2
*
* av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
* // Rescaling AV_NOPTS_VALUE:
* // AV_NOPTS_VALUE == INT64_MIN
* // AV_NOPTS_VALUE is passed through
* // => AV_NOPTS_VALUE
* @endcode
*/
AV_ROUND_PASS_MINMAX = 8192,
};
/**
* Rescale a 64-bit integer with specified rounding.
*
* The operation is mathematically equivalent to `a * b / c`, but writing that
* directly can overflow, and does not support different rounding methods.
* If the result is not representable then INT64_MIN is returned.
*
* @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
*/
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;该函数的作用是：计算整形a乘以整形b再除以整形c（a * b / c）的结果，将结果作为返回值返回。 其中：
AV_ROUND_INF和AV_ROUND_UP：将计算结果向上取整。比如计算结果为4096.4，返回值为4097。
AV_ROUND_ZERO和AV_ROUND_DOWN：将计算结果向下取整。比如计算结果为4096.4，返回值为4096。
AV_ROUND_NEAR_INF：将计算结果四舍五入。比如计算结果为0.4，返回值为0；计算结果为0.6，返回值为1。
（二）av_rescale_rnd函数的定义
av_rescale_rnd函数定义在源文件libavutil/mathematics.c中：
cpp
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
{
int64_t r = 0;
av_assert2(c > 0);
av_assert2(b >=0);
av_assert2((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4);
if (c <= 0 || b < 0 || !((unsigned)(rnd&~AV_ROUND_PASS_MINMAX)<=5 && (rnd&~AV_ROUND_PASS_MINMAX)!=4))
return INT64_MIN;
if (rnd & AV_ROUND_PASS_MINMAX) {
if (a == INT64_MIN || a == INT64_MAX)
return a;
rnd -= AV_ROUND_PASS_MINMAX;
}
if (a < 0)
return -(uint64_t)av_rescale_rnd(-FFMAX(a, -INT64_MAX), b, c, rnd ^ ((rnd >> 1) & 1));
if (rnd == AV_ROUND_NEAR_INF)
r = c / 2;
else if (rnd & 1)
r = c - 1;
if (b <= INT_MAX && c <= INT_MAX) {
if (a <= INT_MAX)
return (a * b + r) / c;
else {
int64_t ad = a / c;
int64_t a2 = (a % c * b + r) / c;
if (ad >= INT32_MAX && b && ad > (INT64_MAX - a2) / b)
return INT64_MIN;
return ad * b + a2;
}
} else {
#if 1
uint64_t a0 = a & 0xFFFFFFFF;
uint64_t a1 = a >> 32;
uint64_t b0 = b & 0xFFFFFFFF;
uint64_t b1 = b >> 32;
uint64_t t1 = a0 * b1 + a1 * b0;
uint64_t t1a = t1 << 32;
int i;
a0 = a0 * b0 + t1a;
a1 = a1 * b1 + (t1 >> 32) + (a0 < t1a);
a0 += r;
a1 += a0 < r;
for (i = 63; i >= 0; i--) {
a1 += a1 + ((a0 >> i) & 1);
t1 += t1;
if (c <= a1) {
a1 -= c;
t1++;
}
}
if (t1 > INT64_MAX)
return INT64_MIN;
return t1;
#else
/* reference code doing (a*b + r) / c, requires libavutil/integer.h */
AVInteger ai;
ai = av_mul_i(av_int2i(a), av_int2i(b));
ai = av_add_i(ai, av_int2i(r));
return av_i2int(av_div_i(ai, av_int2i(c)));
#endif
}
}二、av_rescale_q_rnd函数
（一）av_rescale_q_rnd函数的声明
av_rescale_q_rnd函数声明在头文件libavutil/mathematics.h中：
cpp
/**
* Rescale a 64-bit integer by 2 rational numbers with specified rounding.
*
* The operation is mathematically equivalent to `a * bq / cq`.
*
* @see av_rescale(), av_rescale_rnd(), av_rescale_q()
*/
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
enum AVRounding rnd) av_const;该函数的作用是：计算整形a乘以有理数bq再除以有理数cq（a * bq / cq）的结果，将结果作为返回值返回。 其中：
AV_ROUND_INF和AV_ROUND_UP：将计算结果向上取整。比如计算结果为4096.4，返回值为4097。
AV_ROUND_ZERO和AV_ROUND_DOWN：将计算结果向下取整。比如计算结果为4096.4，返回值为4096。
AV_ROUND_NEAR_INF：将计算结果四舍五入。比如计算结果为0.4，返回值为0；计算结果为0.6，返回值为1。
关于AVRational类型可以参考：《FFmpeg有理数相关的源码：AVRational结构体和其相关的函数分析》
（二）av_rescale_q_rnd函数的定义
av_rescale_q_rnd函数定义在源文件libavutil/mathematics.c中：
cpp
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
enum AVRounding rnd)
{
int64_t b = bq.num * (int64_t)cq.den;
int64_t c = cq.num * (int64_t)bq.den;
return av_rescale_rnd(a, b, c, rnd);
}可以看到av_rescale_q_rnd函数内部调用了av_rescale_rnd函数。
三、av_rescale_q函数
（一）av_rescale_q函数的声明
av_rescale_q函数声明在头文件libavutil/mathematics.h中：
cpp
/**
* Rescale a 64-bit integer by 2 rational numbers.
*
* The operation is mathematically equivalent to `a * bq / cq`.
*
* This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.
*
* @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()
*/
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;该函数的作用是：计算整形a乘以有理数bq再除以有理数cq（a * bq / cq）的结果，将结果作为返回值返回。计算结果四舍五入，比如结果为0.4，返回值为0；结果为0.6，返回值为1。
（二）av_rescale_q函数的定义
av_rescale_q函数定义在源文件libavutil/mathematics.c中：
cpp
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
{
return av_rescale_q_rnd(a, bq, cq, AV_ROUND_NEAR_INF);
}可以看到av_rescale_q函数内部调用了av_rescale_q_rnd函数。
四、av_add_stable函数
（一）av_add_stable函数的声明
av_add_stable函数声明在头文件libavutil/mathematics.h中：
cpp
/**
* Add a value to a timestamp.
*
* This function guarantees that when the same value is repeatly added that
* no accumulation of rounding errors occurs.
*
* @param[in] ts Input timestamp
* @param[in] ts_tb Input timestamp time base
* @param[in] inc Value to be added
* @param[in] inc_tb Time base of `inc`
*/
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);该函数的作用是：计算ts + (inc * inc_tb / ts_tb)的结果，将结果作为返回值返回。
（二）av_add_stable函数的定义
av_add_stable函数定义在源文件libavutil/mathematics.c中：
cpp
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
{
int64_t m, d;
if (inc != 1)
inc_tb = av_mul_q(inc_tb, (AVRational) {inc, 1});
m = inc_tb.num * (int64_t)ts_tb.den;
d = inc_tb.den * (int64_t)ts_tb.num;
if (m % d == 0 && ts <= INT64_MAX - m / d)
return ts + m / d;
if (m < d)
return ts;
{
int64_t old = av_rescale_q(ts, ts_tb, inc_tb);
int64_t old_ts = av_rescale_q(old, inc_tb, ts_tb);
if (old == INT64_MAX || old == AV_NOPTS_VALUE || old_ts == AV_NOPTS_VALUE)
return ts;
return av_sat_add64(av_rescale_q(old + 1, inc_tb, ts_tb), ts - old_ts);
}
}大部分情况下，av_add_stable函数可以化简为：
cpp
int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc)
{
int64_t m, d;
inc_tb = av_mul_q(inc_tb, (AVRational) {inc, 1});
m = inc_tb.num * (int64_t)ts_tb.den;
d = inc_tb.den * (int64_t)ts_tb.num;
return ts + m / d;
}关于av_mul_q函数可以参考：《FFmpeg有理数相关的源码：AVRational结构体和其相关的函数分析》，下面语句相当于执行了inc_tb = inc * inc_tb：
cpp
inc_tb = av_mul_q(inc_tb, (AVRational) {inc, 1});根据小学数学可以知道：分数除法是分数乘法的逆行运算（逆运算），分数除法的计算法则为：甲数除以乙数（0除外），等于甲数乘乙数的倒数。所以m / d相当于执行了inc_tb / ts_tb：
cpp
m = inc_tb.num * (int64_t)ts_tb.den;
d = inc_tb.den * (int64_t)ts_tb.num;所以语句"return ts + m / d" 等价于返回：ts + (inc * inc_tb / ts_tb) 。