x265的DCT

最新推荐文章于 2023-10-24 22:01:31 发布
最新推荐文章于 2023-10-24 22:01:31 发布
阅读量635 收藏
点赞数 1
分类专栏： C++ HEVC 视频编码 文章标签： c++ idct HEVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DuoKingg/article/details/131081581
版权
C++ 同时被 3 个专栏收录
19 篇文章 1 订阅
订阅专栏
视频编码
17 篇文章 0 订阅
订阅专栏
HEVC
11 篇文章 0 订阅
订阅专栏

文章目录

DCT相关背景知识

DCT变换系数矩阵

标准提供了32x32的系数矩阵，4x4、8x8、16x16的矩阵都可以从中提取出来

32x32变换矩阵系数

左半边
右半边

其他尺寸变换矩阵系数

其他尺寸矩阵变换系数
从上面来看，4x4的变换矩阵，系数为：
[ 64 64 64 64 83 36 − 36 − 83 64 − 64 − 64 64 36 − 83 83 − 36 ] \begin{bmatrix} 64 & 64 & 64 & 64 \\ 83 & 36 & -36 & -83 \\ 64 & -64 & -64 & 64 \\ 36 & -83 & 83 & -36 \end{bmatrix} ​64836436​6436−64−83​64−36−6483​64−8364−36​ ​
其他尺寸的变换系数矩阵也可以从图中对应找到

变换计算过程

流程图

流程图
需要注意的是：

  1. 左乘表示列变换，右乘表示行变换
  2. 反变换的过程中，进行了两次Scale

伸缩矩阵，具体定义为：
伸缩矩阵

代码实现

数据

残差变换系数

残差变换系数

对应残差

残差

我的简单实现

实现细节
  1. 实现公式
    R = D T ⋅ C × S I T 1 ⋅ D × S I T 2 R = D^T \cdot C \times S_{IT1} \cdot D \times S_{IT2} R=DT⋅C×SIT1​⋅D×SIT2​
  2. 暂时忽略伸缩
    R = D T ⋅ C ⋅ D R = D^T \cdot C \cdot D R=DT⋅C⋅D
  3. 稍加处理
    R = ( C T ⋅ D ) T ⋅ D R = { (C^T \cdot D) }^T \cdot D R=(CT⋅D)T⋅D
  4. 重点来了，到这里之后。
    就可以把公式可以分成两部分
    T m p = C T ⋅ D R = T m p T ⋅ D Tmp =C^T \cdot D \\ R = { Tmp }^T \cdot D Tmp=CT⋅DR=TmpT⋅D
  5. 加入伸缩
    T m p = C T ⋅ D × S I T 1 R = T m p T ⋅ D × S I T 2 Tmp =C^T \cdot D \times S_{IT1} \\ R = { Tmp }^T \cdot D \times S_{IT2} Tmp=CT⋅D×SIT1​R=TmpT⋅D×SIT2​
  6. 也就是说，我们可以这样定义函数。
    y = f u n ( a , b , s ) = a T ⋅ b × s y = fun(a,b,s) = a^T \cdot b \times s y=fun(a,b,s)=aT⋅b×s
    函数步骤为：先转置，再列变换，然后伸缩
    也就是说，我们只需要实现这个函数，然后调用两次即可
实现代码
// 变换系数
static const signed char transform[32][32] = {
    { 64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
      64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64 },
    { 90,  90,  88,  85,  82,  78,  73,  67,  61,  54,  46,  38,  31,  22,  13,   4,
      -4, -13, -22, -31, -38, -46, -54, -61, -67, -73, -78, -82, -85, -88, -90, -90 },
    { 90,  87,  80,  70,  57,  43,  25,   9,  -9, -25, -43, -57, -70, -80, -87, -90,
     -90, -87, -80, -70, -57, -43, -25,  -9,   9,  25,  43,  57,  70,  80,  87,  90 },
    { 90,  82,  67,  46,  22,  -4, -31, -54, -73, -85, -90, -88, -78, -61, -38, -13,
      13,  38,  61,  78,  88,  90,  85,  73,  54,  31,   4, -22, -46, -67, -82, -90 },
    { 89,  75,  50,  18, -18, -50, -75, -89, -89, -75, -50, -18,  18,  50,  75,  89,
      89,  75,  50,  18, -18, -50, -75, -89, -89, -75, -50, -18,  18,  50,  75,  89 },
    { 88,  67,  31, -13, -54, -82, -90, -78, -46, -4,   38,  73,  90,  85,  61,  22,
     -22, -61, -85, -90, -73, -38,   4,  46,  78,  90,  82,  54,  13, -31, -67, -88 },
    { 87,  57,   9, -43, -80, -90, -70, -25,  25,  70,  90,  80,  43,  -9, -57, -87,
     -87, -57,  -9,  43,  80,  90,  70,  25, -25, -70, -90, -80, -43,   9,  57,  87 },
    { 85,  46, -13, -67, -90, -73, -22,  38,  82,  88,  54,  -4, -61, -90, -78, -31,
      31,  78,  90,  61,   4, -54, -88, -82, -38,  22,  73,  90,  67,  13, -46, -85 },
    { 83,  36, -36, -83, -83, -36,  36,  83,  83,  36, -36, -83, -83, -36,  36,  83,
      83,  36, -36, -83, -83, -36,  36,  83,  83,  36, -36, -83, -83, -36,  36,  83 },
    { 82,  22, -54, -90, -61,  13,  78,  85,  31, -46, -90, -67,   4,  73,  88,  38,
     -38, -88, -73,  -4,  67,  90,  46, -31, -85, -78, -13,  61,  90,  54, -22, -82 },
    { 80,   9, -70, -87, -25,  57,  90,  43, -43, -90, -57,  25,  87,  70,  -9, -80,
     -80,  -9,  70,  87,  25, -57, -90, -43,  43,  90,  57, -25, -87, -70,   9,  80 },
    { 78,  -4, -82, -73,  13,  85,  67, -22, -88, -61,  31,  90,  54, -38, -90, -46,
      46,  90,  38, -54, -90, -31,  61,  88,  22, -67, -85, -13,  73,  82,   4, -78 },
    { 75, -18, -89, -50,  50,  89,  18, -75, -75,  18,  89,  50, -50, -89, -18,  75,
      75, -18, -89, -50,  50,  89,  18, -75, -75,  18,  89,  50, -50, -89, -18,  75 },
    { 73, -31, -90, -22,  78,  67, -38, -90, -13,  82,  61, -46, -88,  -4,  85,  54,
     -54, -85,   4,  88,  46, -61, -82,  13,  90,  38, -67, -78,  22,  90,  31, -73 },
    { 70, -43, -87,   9,  90,  25, -80, -57,  57,  80, -25, -90,  -9,  87,  43, -70,
     -70,  43,  87,  -9, -90, -25,  80,  57, -57, -80,  25,  90,   9, -87, -43,  70 },
    { 67, -54, -78,  38,  85, -22, -90,   4,  90,  13, -88, -31,  82,  46, -73, -61,
      61,  73, -46, -82,  31,  88, -13, -90,  -4,  90,  22, -85, -38,  78,  54, -67 },
    { 64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,
      64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64 },
    { 61, -73, -46,  82,  31, -88, -13,  90,  -4, -90,  22,  85, -38, -78,  54,  67,
     -67, -54,  78,  38, -85, -22,  90,   4, -90,  13,  88, -31, -82,  46,  73, -61 },
    { 57, -80, -25,  90,  -9, -87,  43,  70, -70, -43,  87,   9, -90,  25,  80, -57,
     -57,  80,  25, -90,   9,  87, -43, -70,  70,  43, -87,  -9,  90, -25, -80,  57 },
    { 54, -85,  -4,  88, -46, -61,  82,  13, -90,  38,  67, -78, -22,  90, -31, -73,
      73,  31, -90,  22,  78, -67, -38,  90, -13, -82,  61,  46, -88,   4,  85, -54 },
    { 50, -89,  18,  75, -75, -18,  89, -50, -50,  89, -18, -75,  75,  18, -89,  50,
      50, -89,  18,  75, -75, -18,  89, -50, -50,  89, -18, -75,  75,  18, -89,  50 },
    { 46, -90,  38,  54, -90,  31,  61, -88,  22,  67, -85,  13,  73, -82,   4,  78,
     -78,  -4,  82, -73, -13,  85, -67, -22,  88, -61, -31,  90, -54, -38,  90, -46 },
    { 43, -90,  57,  25, -87,  70,   9, -80,  80,  -9, -70,  87, -25, -57,  90, -43,
     -43,  90, -57, -25,  87, -70,  -9,  80, -80,   9,  70, -87,  25,  57, -90,  43 },
    { 38, -88,  73,  -4, -67,  90, -46, -31,  85, -78,  13,  61, -90,  54,  22, -82,
      82, -22, -54,  90, -61, -13,  78, -85,  31,  46, -90,  67,   4, -73,  88, -38 },
    { 36, -83,  83, -36, -36,  83, -83,  36,  36, -83,  83, -36, -36,  83, -83,  36,
      36, -83,  83, -36, -36,  83, -83,  36,  36, -83,  83, -36, -36,  83, -83,  36 },
    { 31, -78,  90, -61,   4,  54, -88,  82, -38, -22,  73, -90,  67, -13, -46,  85,
     -85,  46,  13, -67,  90, -73,  22,  38, -82,  88, -54,  -4,  61, -90,  78, -31 },
    { 25, -70,  90, -80,  43,   9, -57,  87, -87,  57,  -9, -43,  80, -90,  70, -25,
     -25,  70, -90,  80, -43,  -9,  57, -87,  87, -57,   9,  43, -80,  90, -70,  25 },
    { 22, -61,  85, -90,  73, -38,  -4,  46, -78,  90, -82,  54, -13, -31,  67, -88,
      88, -67,  31,  13, -54,  82, -90,  78, -46,   4,  38, -73,  90, -85,  61, -22 },
    { 18, -50,  75, -89,  89, -75,  50, -18, -18,  50, -75,  89, -89,  75, -50,  18,
      18, -50,  75, -89,  89, -75,  50, -18, -18,  50, -75,  89, -89,  75, -50,  18 },
    { 13, -38,  61, -78,  88, -90,  85, -73,  54, -31,   4,  22, -46,  67, -82,  90,
     -90,  82, -67,  46, -22,  -4,  31, -54,  73, -85,  90, -88,  78, -61,  38, -13 },
    {  9, -25,  43, -57,  70, -80,  87, -90,  90, -87,  80, -70,  57, -43,  25, -9,
      -9,  25, -43,  57, -70,  80, -87,  90, -90,  87, -80,  70, -57,  43, -25,   9 },
    {  4, -13,  22, -31,  38, -46,  54, -61,  67, -73,  78, -82,  85, -88,  90, -90,
      90, -90,  88, -85,  82, -78,  73, -67,  61, -54,  46, -38,  31, -22,  13,  -4 },
};

// 残差变换系数
short coeffs1[16 * 16] = {
-8730, -180,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   90,    0,  -90,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0
};

// 
static void func(short* src, short* dst, int s) {
    short add = (1 << (s - 1));
    for (int r1 = 0; r1 < 16; ++r1) {
        for (int c2 = 0; c2 < 16; ++c2) {
            int tmp = 0;
            for (int t = 0; t < 16; ++t)
                tmp += src[r1 + t * 16] * transform[2 * t][c2];
            dst[r1 * 16 + c2] = ((tmp + add) >> s);
        }
    }
}

static void MyIDCT(short* src, short* dst) {
    func(src, dst, 7);
    func(dst, src, 12);
}

x265对应代码实现

const short g_t16[16][16] =
{
    { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 },
    { 90, 87, 80, 70, 57, 43, 25,  9, -9, -25, -43, -57, -70, -80, -87, -90 },
    { 89, 75, 50, 18, -18, -50, -75, -89, -89, -75, -50, -18, 18, 50, 75, 89 },
    { 87, 57,  9, -43, -80, -90, -70, -25, 25, 70, 90, 80, 43, -9, -57, -87 },
    { 83, 36, -36, -83, -83, -36, 36, 83, 83, 36, -36, -83, -83, -36, 36, 83 },
    { 80,  9, -70, -87, -25, 57, 90, 43, -43, -90, -57, 25, 87, 70, -9, -80 },
    { 75, -18, -89, -50, 50, 89, 18, -75, -75, 18, 89, 50, -50, -89, -18, 75 },
    { 70, -43, -87,  9, 90, 25, -80, -57, 57, 80, -25, -90, -9, 87, 43, -70 },
    { 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64 },
    { 57, -80, -25, 90, -9, -87, 43, 70, -70, -43, 87,  9, -90, 25, 80, -57 },
    { 50, -89, 18, 75, -75, -18, 89, -50, -50, 89, -18, -75, 75, 18, -89, 50 },
    { 43, -90, 57, 25, -87, 70,  9, -80, 80, -9, -70, 87, -25, -57, 90, -43 },
    { 36, -83, 83, -36, -36, 83, -83, 36, 36, -83, 83, -36, -36, 83, -83, 36 },
    { 25, -70, 90, -80, 43,  9, -57, 87, -87, 57, -9, -43, 80, -90, 70, -25 },
    { 18, -50, 75, -89, 89, -75, 50, -18, -18, 50, -75, 89, -89, 75, -50, 18 },
    {  9, -25, 43, -57, 70, -80, 87, -90, 90, -87, 80, -70, 57, -43, 25, -9 }
};

static void partialButterflyInverse16(const short* src, short* dst, int shift, int line)
{
    int j, k;
    int E[8], O[8];
    int EE[4], EO[4];
    int EEE[2], EEO[2];
    int add = 1 << (shift - 1);

    for (j = 0; j < line; j++)
    {
        /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
        for (k = 0; k < 8; k++)
        {
            O[k] = g_t16[1][k] * src[line] + g_t16[3][k] * src[3 * line] + g_t16[5][k] * src[5 * line] + g_t16[7][k] * src[7 * line] +
                g_t16[9][k] * src[9 * line] + g_t16[11][k] * src[11 * line] + g_t16[13][k] * src[13 * line] + g_t16[15][k] * src[15 * line];
        }

        for (k = 0; k < 4; k++)
        {
            EO[k] = g_t16[2][k] * src[2 * line] + g_t16[6][k] * src[6 * line] + g_t16[10][k] * src[10 * line] + g_t16[14][k] * src[14 * line];
        }

        EEO[0] = g_t16[4][0] * src[4 * line] + g_t16[12][0] * src[12 * line];
        EEE[0] = g_t16[0][0] * src[0] + g_t16[8][0] * src[8 * line];
        EEO[1] = g_t16[4][1] * src[4 * line] + g_t16[12][1] * src[12 * line];
        EEE[1] = g_t16[0][1] * src[0] + g_t16[8][1] * src[8 * line];

        /* Combining even and odd terms at each hierarchy levels to calculate the final spatial domain vector */
        for (k = 0; k < 2; k++)
        {
            EE[k] = EEE[k] + EEO[k];
            EE[k + 2] = EEE[1 - k] - EEO[1 - k];
        }

        for (k = 0; k < 4; k++)
        {
            E[k] = EE[k] + EO[k];
            E[k + 4] = EE[3 - k] - EO[3 - k];
        }

        for (k = 0; k < 8; k++)
        {
            dst[k] = (short)x265_clip3(-32768, 32767, (E[k] + O[k] + add) >> shift);
            dst[k + 8] = (short)x265_clip3(-32768, 32767, (E[7 - k] - O[7 - k] + add) >> shift);
        }

        src++;
        dst += 16;
    }
}

static void idct16_c(const short* src, short* dst, __int64 dstStride)
{
    const int shift_1st = 7;
    const int shift_2nd = 12 - (X265_DEPTH - 8);

    ALIGN_VAR_32(short, coef[16 * 16]);
    ALIGN_VAR_32(short, block[16 * 16]);

    partialButterflyInverse16(src, coef, shift_1st, 16);
    partialButterflyInverse16(coef, block, shift_2nd, 16);

    for (int i = 0; i < 16; i++)
    {
        memcpy(&dst[i * dstStride], &block[i * 16], 16 * sizeof(short));
    }
}

openHEVC代码实现

static const signed char transform[32][32] = {
    { 64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
      64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64,  64 },
    { 90,  90,  88,  85,  82,  78,  73,  67,  61,  54,  46,  38,  31,  22,  13,   4,
      -4, -13, -22, -31, -38, -46, -54, -61, -67, -73, -78, -82, -85, -88, -90, -90 },
    { 90,  87,  80,  70,  57,  43,  25,   9,  -9, -25, -43, -57, -70, -80, -87, -90,
     -90, -87, -80, -70, -57, -43, -25,  -9,   9,  25,  43,  57,  70,  80,  87,  90 },
    { 90,  82,  67,  46,  22,  -4, -31, -54, -73, -85, -90, -88, -78, -61, -38, -13,
      13,  38,  61,  78,  88,  90,  85,  73,  54,  31,   4, -22, -46, -67, -82, -90 },
    { 89,  75,  50,  18, -18, -50, -75, -89, -89, -75, -50, -18,  18,  50,  75,  89,
      89,  75,  50,  18, -18, -50, -75, -89, -89, -75, -50, -18,  18,  50,  75,  89 },
    { 88,  67,  31, -13, -54, -82, -90, -78, -46, -4,   38,  73,  90,  85,  61,  22,
     -22, -61, -85, -90, -73, -38,   4,  46,  78,  90,  82,  54,  13, -31, -67, -88 },
    { 87,  57,   9, -43, -80, -90, -70, -25,  25,  70,  90,  80,  43,  -9, -57, -87,
     -87, -57,  -9,  43,  80,  90,  70,  25, -25, -70, -90, -80, -43,   9,  57,  87 },
    { 85,  46, -13, -67, -90, -73, -22,  38,  82,  88,  54,  -4, -61, -90, -78, -31,
      31,  78,  90,  61,   4, -54, -88, -82, -38,  22,  73,  90,  67,  13, -46, -85 },
    { 83,  36, -36, -83, -83, -36,  36,  83,  83,  36, -36, -83, -83, -36,  36,  83,
      83,  36, -36, -83, -83, -36,  36,  83,  83,  36, -36, -83, -83, -36,  36,  83 },
    { 82,  22, -54, -90, -61,  13,  78,  85,  31, -46, -90, -67,   4,  73,  88,  38,
     -38, -88, -73,  -4,  67,  90,  46, -31, -85, -78, -13,  61,  90,  54, -22, -82 },
    { 80,   9, -70, -87, -25,  57,  90,  43, -43, -90, -57,  25,  87,  70,  -9, -80,
     -80,  -9,  70,  87,  25, -57, -90, -43,  43,  90,  57, -25, -87, -70,   9,  80 },
    { 78,  -4, -82, -73,  13,  85,  67, -22, -88, -61,  31,  90,  54, -38, -90, -46,
      46,  90,  38, -54, -90, -31,  61,  88,  22, -67, -85, -13,  73,  82,   4, -78 },
    { 75, -18, -89, -50,  50,  89,  18, -75, -75,  18,  89,  50, -50, -89, -18,  75,
      75, -18, -89, -50,  50,  89,  18, -75, -75,  18,  89,  50, -50, -89, -18,  75 },
    { 73, -31, -90, -22,  78,  67, -38, -90, -13,  82,  61, -46, -88,  -4,  85,  54,
     -54, -85,   4,  88,  46, -61, -82,  13,  90,  38, -67, -78,  22,  90,  31, -73 },
    { 70, -43, -87,   9,  90,  25, -80, -57,  57,  80, -25, -90,  -9,  87,  43, -70,
     -70,  43,  87,  -9, -90, -25,  80,  57, -57, -80,  25,  90,   9, -87, -43,  70 },
    { 67, -54, -78,  38,  85, -22, -90,   4,  90,  13, -88, -31,  82,  46, -73, -61,
      61,  73, -46, -82,  31,  88, -13, -90,  -4,  90,  22, -85, -38,  78,  54, -67 },
    { 64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,
      64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64,  64, -64, -64,  64 },
    { 61, -73, -46,  82,  31, -88, -13,  90,  -4, -90,  22,  85, -38, -78,  54,  67,
     -67, -54,  78,  38, -85, -22,  90,   4, -90,  13,  88, -31, -82,  46,  73, -61 },
    { 57, -80, -25,  90,  -9, -87,  43,  70, -70, -43,  87,   9, -90,  25,  80, -57,
     -57,  80,  25, -90,   9,  87, -43, -70,  70,  43, -87,  -9,  90, -25, -80,  57 },
    { 54, -85,  -4,  88, -46, -61,  82,  13, -90,  38,  67, -78, -22,  90, -31, -73,
      73,  31, -90,  22,  78, -67, -38,  90, -13, -82,  61,  46, -88,   4,  85, -54 },
    { 50, -89,  18,  75, -75, -18,  89, -50, -50,  89, -18, -75,  75,  18, -89,  50,
      50, -89,  18,  75, -75, -18,  89, -50, -50,  89, -18, -75,  75,  18, -89,  50 },
    { 46, -90,  38,  54, -90,  31,  61, -88,  22,  67, -85,  13,  73, -82,   4,  78,
     -78,  -4,  82, -73, -13,  85, -67, -22,  88, -61, -31,  90, -54, -38,  90, -46 },
    { 43, -90,  57,  25, -87,  70,   9, -80,  80,  -9, -70,  87, -25, -57,  90, -43,
     -43,  90, -57, -25,  87, -70,  -9,  80, -80,   9,  70, -87,  25,  57, -90,  43 },
    { 38, -88,  73,  -4, -67,  90, -46, -31,  85, -78,  13,  61, -90,  54,  22, -82,
      82, -22, -54,  90, -61, -13,  78, -85,  31,  46, -90,  67,   4, -73,  88, -38 },
    { 36, -83,  83, -36, -36,  83, -83,  36,  36, -83,  83, -36, -36,  83, -83,  36,
      36, -83,  83, -36, -36,  83, -83,  36,  36, -83,  83, -36, -36,  83, -83,  36 },
    { 31, -78,  90, -61,   4,  54, -88,  82, -38, -22,  73, -90,  67, -13, -46,  85,
     -85,  46,  13, -67,  90, -73,  22,  38, -82,  88, -54,  -4,  61, -90,  78, -31 },
    { 25, -70,  90, -80,  43,   9, -57,  87, -87,  57,  -9, -43,  80, -90,  70, -25,
     -25,  70, -90,  80, -43,  -9,  57, -87,  87, -57,   9,  43, -80,  90, -70,  25 },
    { 22, -61,  85, -90,  73, -38,  -4,  46, -78,  90, -82,  54, -13, -31,  67, -88,
      88, -67,  31,  13, -54,  82, -90,  78, -46,   4,  38, -73,  90, -85,  61, -22 },
    { 18, -50,  75, -89,  89, -75,  50, -18, -18,  50, -75,  89, -89,  75, -50,  18,
      18, -50,  75, -89,  89, -75,  50, -18, -18,  50, -75,  89, -89,  75, -50,  18 },
    { 13, -38,  61, -78,  88, -90,  85, -73,  54, -31,   4,  22, -46,  67, -82,  90,
     -90,  82, -67,  46, -22,  -4,  31, -54,  73, -85,  90, -88,  78, -61,  38, -13 },
    {  9, -25,  43, -57,  70, -80,  87, -90,  90, -87,  80, -70,  57, -43,  25, -9,
      -9,  25, -43,  57, -70,  80, -87,  90, -90,  87, -80,  70, -57,  43, -25,   9 },
    {  4, -13,  22, -31,  38, -46,  54, -61,  67, -73,  78, -82,  85, -88,  90, -90,
      90, -90,  88, -85,  82, -78,  73, -67,  61, -54,  46, -38,  31, -22,  13,  -4 },
};
static __forceinline short av_clip_int16(int a)
{
    if ((a + 0x8000U) & ~0xFFFF) return (a >> 31) ^ 0x7FFF;
    else                      return a;
}

#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define SET(dst, x)   (dst) = (x)
#define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)

#define TR_4(dst, src, dstep, sstep, assign, end)                 \
    do {                                                          \
        const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep]; \
        const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep]; \
        const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep]; \
        const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep]; \
                                                                  \
        assign(dst[0 * dstep], e0 + o0);                          \
        assign(dst[1 * dstep], e1 + o1);                          \
        assign(dst[2 * dstep], e1 - o1);                          \
        assign(dst[3 * dstep], e0 - o0);                          \
    } while (0)

#define TR_8(dst, src, dstep, sstep, assign, end)                 \
    do {                                                          \
        int i, j;                                                 \
        int e_8[4];                                               \
        int o_8[4] = { 0 };                                       \
        for (i = 0; i < 4; i++)                                   \
            for (j = 1; j < end; j += 2)                          \
                o_8[i] += transform[4 * j][i] * src[j * sstep];   \
        TR_4(e_8, src, 1, 2 * sstep, SET, 4);                     \
                                                                  \
        for (i = 0; i < 4; i++) {                                 \
            assign(dst[i * dstep], e_8[i] + o_8[i]);              \
            assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);        \
        }                                                         \
    } while (0)

#define TR_16(dst, src, dstep, sstep, assign, end)                \
    do {                                                          \
        int i, j;                                                 \
        int e_16[8];                                              \
        int o_16[8] = { 0 };                                      \
        for (i = 0; i < 8; i++)                                   \
            for (j = 1; j < end; j += 2)                          \
                o_16[i] += transform[2 * j][i] * src[j * sstep];  \
        TR_8(e_16, src, 1, 2 * sstep, SET, 8);                    \
                                                                  \
        for (i = 0; i < 8; i++) {                                 \
            assign(dst[i * dstep], e_16[i] + o_16[i]);            \
            assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);     \
        }                                                         \
    } while (0)

static void idct_16x16_8(short* coeffs, int col_limit) {
    int i;
    int      shift = 7;
    int      add = 1 << (shift - 1);
    short* src = coeffs;
    int limit = FFMIN(col_limit, 16);
    int limit2 = FFMIN(col_limit + 4, 16);

    for (i = 0; i < 16; i++) {
        TR_16(src, src, 16, 16, SCALE, limit2);                  
        if (limit2 < 16 && i%4 == 0 && !!i)                        
            limit2 -= 4;                                         
        src++;                                                    
    }      
    shift = 20 - BIT_DEPTH;                                       
    add = 1 << (shift - 1);                                     
    for (i = 0; i < 16; i++) {
        TR_16(coeffs, coeffs, 1, 1, SCALE, limit);             
        coeffs += 16;                                              
    }                                                             
};
你好，请叫我靓仔
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Codecs系列】HEVC标准（七）：变换量化技术及x265实现分析
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
01-05 1121
Date: 2022.1.5 文章目录1、变换编码1.1、整数DCT1.1.1、基本原理1.1.2、公式推导过程1.2、整数DST1.3、DCT反变换1.4、变换四叉树1.5、哈达玛变换2、量化技术2.1、传统标量量化2.2、反量化2.3、RDOQ2.4、量化参数和量化矩阵 1、变换编码 图像变换编码是指将以空间域中像素形式描述的图像转换至空间域，以变换系数的形式加以表示。绝大多数图像都含有较多平坦区域和内容变换缓慢的区域，适当的变换可使图像能量在空间域的分散分布转为在变换域的相对集中分布，以达到去除空间
x265 中的变换操作
fantasy_ARM9的博客
03-10 295
x265 变换操作 rdoq 量化
【待写】HEVC的三种编码结构以及对应的在x265中的实现
video coding
07-07 281
CRA
H265和H264编解码中DCT变换过程中scaling 和 strong_intra_smooth
cy413026的博客
06-26 1306
strong_intra_smooth:是H265的intra预测过程中，对相邻pix进行的双线性滤波，属于协议内容 scaling是DCT变换过程中的，用于归一化，为了保证残差块经过变换和反变换之后基准相同，HEVC在变换模块中还增加了额外的缩放参考HEVC中变换（Transform）过程中的scaling操作的理解 ...
8x8点DCT变换matlab代码
07-10
8点DCT 变换matlab算法，通过乘加实现。 适用于jpeg编码
x265中dct4函数的向量实现
XX_bai的博客
08-09 424
摘要 对于DCT函数，不同尺寸函数的实现存在较大的差异。因此在这一系列中，会分别讲述DCT函数不同尺寸的实现方法及原理。本文讲述的是4x4尺寸的内容。4x4尺寸较小，不会达到寄存器数量的极限，数据构造简单，实现相对较为容易，重点讲述一下原理。 正文 原理 DCT函数的实现原理其实是基于FFT的蝶形算法，一定程度上减少加法、乘法运算的次数。具体来看。 在H.265/HEVC中4x4整数DCT公式为：...
x265最新源码x265_3.5.tar.gz
03-31
4. **变换与量化**：x265使用离散余弦变换（DCT）和离散正交调幅变换（DQT）对块内的像素值进行变换，将空间域的信号转换为频率域，便于去除冗余信息。量化是压缩的关键步骤，通过舍弃部分高频系数来降低码率，但会...
x265开源代码的实现与框架
12-31
《x265开源代码的实现与框架》 在当今数字化时代，视频编码技术的发展对音视频传输和存储效率产生了深远影响。其中，x265是基于HEVC（High Efficiency Video Coding，高效视频编码）标准的一个开源实现，它极大地...
x265_3.1.２.rar
05-25
《深入探索x265：HEVC编码器的开源实践》 在当今的数字媒体领域，视频编码技术的发展日新月异，其中x265是实现高效视频编码（High Efficiency Video Coding，简称HEVC）的重要开源工具。本文将围绕“x265_3.1.2”这...
x265_2.9.tar.gz 源码
01-16
《深入解析x265编码器：源自x265_2.9.tar.gz源码》 在视频编码领域，x265是一款基于HEVC（High Efficiency Video Coding，高效视频编码）标准的开源视频编码器。HEVC是继H.264/AVC之后的新一代编码标准，其目标是在...
x265-src.tar.gz
02-04
《x265编码技术深度解析》 x265编码技术是现代视频编码领域中的重要组成部分，尤其在高效率视频编码（High Efficiency Video Coding, HEVC）标准中扮演着核心角色。x265是开源实现HEVC编码器的一个项目，其源代码...
HEVC/H.265理论知识（5）——变换
NB_vol_1的专栏
11-22 4470
一、变换编码的：绝对大部分图像都含有较多的平坦区域内容变化缓慢的区域，变换可以使图像能量在空间域的分散分布转为在变换域的相对集中分布，就可以达到去除空间冗余的目的 二、HEVC使用了DCT和DST（只用于4x4的小块）两种变换，为了加快速度，还会使用Hadamard算法（HEVC标准中没有使用，但是自己的具体实现可以使用）。二维DCT可以分成两个一维的DCT变换。 三、HEVC
H.265/HEVC学习笔记：变换
一直在笑的博客
11-22 1276
一、 原理         图像变换编码是指将以空间域中像素形式描述的图像转换至变换域（频域），以变换系数的形式加以表示。由于绝大多数图像都含有较多平坦区域和内容变化缓慢的区域，适当的变换可使图像能量在空间域的分散分布转换为在变换域的相对集中分布，以达到去除空间冗余的目的。         在H.265/HEVC中，对经过预测编码后的预测残差进行变换，并根据预测残差的特点使用离散余弦变换和离散正弦变换两种变换方式。 二、离散余
OpenCV实现基于8*8块DCT变换的图像压缩
以后以后的专栏
03-21 1万+
这几天一直在看MPEG编解码的原理，由于利用ffmpeg实在提不出DCT系数，就根据MPEG的编码原理来看看这个DCT系数到底什么样，于是在OpenCV中实现了一下图像压缩这一块，基于8*8块DCT变换，同时也再进行了一下反变换，最后得到了原图。 代码如下： #include "highgui.h" #include #include using namespace std; using n
【x265编码器】章节8——变换量化模块
最新发布
vcvdv123的博客
10-24 1万+
1.useTransformSkip模式，此时会直接复制到量化内存中；4.如果开启了m_rdoqLevel，此时采用RDOQ的变换量化操作；2.4x4帧内模式，使用dst4x4进行4x4的dst变换；5.使用m_quantCoef进行常规量化操作；3.常规的dct变换；
整数DCT蝶形算法
热门推荐
Dillon2015的博客
04-13 5万+
在H.265/HEVC中支持4种不同尺寸的整数DCT变换，分别是4x4、8x8、16x16、32x32。 各种尺寸的DCT矩阵 对应的变化矩阵如下： 4x4变换矩阵： 8x8变换矩阵： 16x16变换矩阵： 下面分别是32x32变换矩阵的左边16列和右边16列： 我们可以发现以上矩阵有如下特点： 以上矩阵都是左右对称的，但是对称方式有所不同，偶数行的标准对称...
H.264 VS H.265 变换编码及量化过程分析（2）
biaobiao009的专栏
07-19 1590
量化是视频编码中产生失真的根本原因，它同时影响着编码质量和比特率。 Quantize原理 Quantization parameter and step Quantization在编码中的应用 Quantization在编码中的实现 Quantization在编码中，不同系数采用的方案 Quantization在编码中，优化方案 Quantization在编码中，涉及的码流参数 Quantize原理 量化是指将信号的连续取值，映射为有限多个离散幅值的过程，实现信号多对一的映射。量.
几种不同大小的dct变换
六月的雨的博客
06-19 510
static void partialButterfly16(const int16_t* src, int16_t* dst, int shift, int line) { int j, k; int E[8], O[8]; int EE[4], EO[4]; int EEE[2], EEO[2]; int add = 1 << (shift - 1); for (j = 0; j < line; j++) { .
H.264 视频编码器 变换编码分析
Ter23LBJ的博客
05-30 1223
H.264 视频编码器 变换编码分析 1. 变换编码分为两部分：变换，量化，以及在之后的重建环路中对应的反量化和反变换。 接下来对各部分进行分析 2.变换 根据残差数据的类型不同，H264 High Profile中会使用到4种不同的变换： 采用 Intra4x4 预测模式和 Intra16x16 预测模式得到的亮度分量预测残差，使用4x4离散余弦变换（DCT）； 采用 Intra8x8 预测模...
matlab dct
08-16
DCT，即离散余弦变换（Discrete Cosine Transform），是一种常用的信号处理技术，尤其在图像和音频压缩中得到广泛应用。在MATLAB中，你可以使用dct函数来对信号进行DCT变换。 以下是一个简单的示例，展示了如何在MATLAB中使用dct函数对信号进行DCT变换和逆变换： ```matlab % 定义输入信号 x = [1 2 3 4 5]; % 进行DCT变换 X = dct(x); % 打印DCT系数 disp('DCT系数：'); disp(X); % 进行逆DCT变换 x_recovered = idct(X); % 打印逆变换结果 disp('逆DCT变换结果：'); disp(x_recovered); ``` 运行以上代码，你将得到以下输出： ``` DCT系数： 15.0000 -4.4409 -1.3819 -0.0000 -0.1180 逆DCT变换结果： 1.0000 2.0000 3.0000 4.0000 5.0000 ``` 这个示例展示了一个简单的一维信号的DCT变换和逆变换过程。你可以根据自己的需要修改输入信号x，并通过dct和idct函数实现DCT变换和逆变换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值