FFmpeg源码：av_gcd函数分析

news2024/11/14 15:31:21

一、引言

公约数，是一个能同时整除几个整数的数。如果一个整数同时是几个整数的约数，称这个整数为它们的“公约数”；公约数中最大的称为最大公约数。对任意的若干个正整数，1总是它们的公约数。
公约数与公倍数相反，就是既是A的约数同时也是B的约数的数，12和15的公约数有1，3，最大公约数就是3。再举个例子，30和40，它们的公约数有1，2，5，10，最大公约数是10。FFmpeg源码中使用av_gcd函数来计算两个整数的最大公约数。

二、av_gcd函数的声明

av_gcd函数声明在FFmpeg源码（本文演示用的FFmpeg源码版本为7.0.1）的头文件libavutil/mathematics.h中：

/**
 * Compute the greatest common divisor of two integer operands.
 *
 * @param a Operand
 * @param b Operand
 * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
 * if a == 0 and b == 0, returns 0.
 */
int64_t av_const av_gcd(int64_t a, int64_t b);

该函数作用是：计算两个整数操作数的最大公约数。

形参a：输入型参数。第一个整数操作数。

形参b：输入型参数。第二个整数操作数。

返回值：两个整数操作数a和b的最大公约数。如果a和b都不小于0，返回值不小于0；如果a和b都等于0，返回值等于0（0既不是质数也不是合数且它没有任何约数，最好避免形参值为0的情况）。

三、av_gcd函数的定义

av_gcd函数定义在FFmpeg源码的源文件libavutil/mathematics.c中：

/* Stein's binary GCD algorithm:
 * https://en.wikipedia.org/wiki/Binary_GCD_algorithm */
int64_t av_gcd(int64_t a, int64_t b) {
    int za, zb, k;
    int64_t u, v;
    if (a == 0)
        return b;
    if (b == 0)
        return a;
    za = ff_ctzll(a);
    zb = ff_ctzll(b);
    k  = FFMIN(za, zb);
    u = llabs(a >> za);
    v = llabs(b >> zb);
    while (u != v) {
        if (u > v)
            FFSWAP(int64_t, v, u);
        v -= u;
        v >>= ff_ctzll(v);
    }
    return (uint64_t)u << k;
}

该函数内部使用了二进制GCD算法寻找两个整数操作数的最大公约数。二进制GCD算法(binary GCD algorithm)，也被称为Stein's算法或二进制欧氏算法(binary Euclidean algorithm)，是一种计算两个非负整数的最大公约数(GCD)的算法。Stein's算法比传统的Euclidean算法使用更简单的算术运算，它用算术移位、比较和减法代替除法（用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以想办法用移位的方法得到结果。整数除法是整数运算中最慢的，所以应该尽可能避免）。

虽然这种现代形式的算法是由物理学家和程序员Josef Stein在1967年首次发表的，但它在公元前2世纪，即古代中国被人们所知。

四、编写av_gcd函数的使用例子

编写测试例子main.c，在Ubuntu中使用9.4.0版本的gcc编译通过：

#include <stdio.h>
#include <stdint.h>
#include <limits.h>
#include <features.h>


#ifdef __GNUC__
#    define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
#    define AV_GCC_VERSION_AT_MOST(x,y)  (__GNUC__ < (x) || __GNUC__ == (x) && __GNUC_MINOR__ <= (y))
#else
#    define AV_GCC_VERSION_AT_LEAST(x,y) 0
#    define AV_GCC_VERSION_AT_MOST(x,y)  0
#endif


#ifndef av_always_inline
#if AV_GCC_VERSION_AT_LEAST(3,1)
#    define av_always_inline __attribute__((always_inline)) inline
#elif defined(_MSC_VER)
#    define av_always_inline __forceinline
#else
#    define av_always_inline inline
#endif
#endif


#if AV_GCC_VERSION_AT_LEAST(2,6) || defined(__clang__)
#    define av_const __attribute__((const))
#else
#    define av_const
#endif


#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)


#ifdef __USE_ISOC99
__extension__ extern long long int llabs (long long int __x)
     __THROW __attribute__ ((__const__)) __wur;
#endif


#ifndef ff_ctzll
#define ff_ctzll ff_ctzll_c
/* We use the De-Bruijn method outlined in:
 * http://supertech.csail.mit.edu/papers/debruijn.pdf. */
static av_always_inline av_const int ff_ctzll_c(long long v)
{
    static const uint8_t debruijn_ctz64[64] = {
        0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
        62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
        63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
        51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
    };
    return debruijn_ctz64[(uint64_t)((v & -v) * 0x022FDD63CC95386DU) >> 58];
}
#endif




int64_t av_gcd(int64_t a, int64_t b) {
    int za, zb, k;
    int64_t u, v;
    if (a == 0)
        return b;
    if (b == 0)
        return a;
    za = ff_ctzll(a);
    zb = ff_ctzll(b);
    k  = FFMIN(za, zb);
    u = llabs(a >> za);
    v = llabs(b >> zb);
    while (u != v) {
        if (u > v)
            FFSWAP(int64_t, v, u);
        v -= u;
        v >>= ff_ctzll(v);
    }
    return (uint64_t)u << k;
}


int main()
{
    int64_t a = 12;
    int64_t b = 15;
    printf("av_gcd(%ld, %ld): %ld\n", a, b, av_gcd(a, b));

    int64_t c = 30;
    int64_t d = 40;
    printf("av_gcd(%ld, %ld): %ld\n", c, d, av_gcd(c, d));

    int64_t e = 0;
    int64_t f = 5;
    printf("av_gcd(%ld, %ld): %ld\n", e, f, av_gcd(e, f));

    int64_t g = 0;
    int64_t h = 0;
    printf("av_gcd(%ld, %ld): %ld\n", g, h, av_gcd(g, h));

    return 0;
}

输出如下：