FFmpeg源码：av_rescale_rnd、av_rescale_q_rnd、av_rescale_q、av_add_stable函数分析

=================================================================

AVRational结构体和其相关的函数分析：

FFmpeg有理数相关的源码：AVRational结构体和其相关的函数分析

FFmpeg源码：av_reduce函数分析

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中：

/*** 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中：

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 1uint64_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中：

/*** 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中：

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中：

/*** 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中：

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中：

/*** 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中：

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函数可以化简为：

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：

inc_tb = av_mul_q(inc_tb, (AVRational) {inc, 1});

根据小学数学可以知道：分数除法是分数乘法的逆行运算（逆运算），分数除法的计算法则为：甲数除以乙数（0除外），等于甲数乘乙数的倒数。所以m / d相当于执行了inc_tb / ts_tb：

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) 。

五、参考

《ffmpeg 中av_rescale_rnd 的含义》

《av_rescale_rnd计算原理》