精华内容
下载资源
问答
  • 蝶形算法详解

    2012-03-08 20:08:30
    针对快速傅里叶,离散余弦等正交变换锁用到的蝶形算法做详细的解释
  • 玻恩近似,多重散射和蝶形算法
  • 这是一款用矩阵分解算法实现的FFT蝶形算法,根据著名的fast algorithm of DCT 1974年的论文实现
  • 整数DCT蝶形算法

    万次阅读 2020-04-13 10:38:28
    在H.265/HEVC中支持4种不同尺寸的整数DCT变换,分别是4x4、8x8、16x16、32x32。 各种尺寸的DCT矩阵 对应的变化矩阵如下: 4x4变换矩阵: ... 以上矩阵都是左右对称的,但是对称方式有所不同,偶数行的标准对称...

    在H.265/HEVC中支持4种不同尺寸的整数DCT变换,分别是4x4、8x8、16x16、32x32。

    各种尺寸的DCT矩阵

    对应的变化矩阵如下:

    4x4变换矩阵:

    8x8变换矩阵:

    16x16变换矩阵:

    下面分别是32x32变换矩阵的左边16列和右边16列:

    我们可以发现以上矩阵有如下特点:

    • 以上矩阵都是左右对称的,但是对称方式有所不同,偶数行的标准对称,奇数行互为相反数。

    • 所有矩阵都可以通过32x32矩阵亚采样得到。如16x16矩阵可由32x32矩阵偶数行的前16个元素组成;8x8矩阵可由32x32矩阵的第0、4、8、12、16、20、24、28行的前8个元素组成;4x4矩阵可由8x8矩阵第0、2、4、6行的前4个元素组成。

    下面是32x32矩阵的前16列及其亚采样情况:

    HM中DCT矩阵的定义

    DCT变换的正变换和逆变换的矩阵定义是相同的,都是上面定义的矩阵。

    const TMatrixCoeff g_aiT4 [TRANSFORM_NUMBER_OF_DIRECTIONS][4][4]   =
    {
      DEFINE_DCT4x4_MATRIX  (   64,    83,    36),
      DEFINE_DCT4x4_MATRIX  (   64,    83,    36)
    };
    
    const TMatrixCoeff g_aiT8 [TRANSFORM_NUMBER_OF_DIRECTIONS][8][8]   =
    {
      DEFINE_DCT8x8_MATRIX  (   64,    83,    36,    89,    75,    50,    18),
      DEFINE_DCT8x8_MATRIX  (   64,    83,    36,    89,    75,    50,    18)
    };
    
    const TMatrixCoeff g_aiT16[TRANSFORM_NUMBER_OF_DIRECTIONS][16][16] =
    {
      DEFINE_DCT16x16_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9),
      DEFINE_DCT16x16_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9)
    };
    
    const TMatrixCoeff g_aiT32[TRANSFORM_NUMBER_OF_DIRECTIONS][32][32] =
    {
      DEFINE_DCT32x32_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9,    90,    90,    88,    85,    82,    78,    73,    67,    61,    54,    46,    38,    31,    22,    13,     4),
      DEFINE_DCT32x32_MATRIX(   64,    83,    36,    89,    75,    50,    18,    90,    87,    80,    70,    57,    43,    25,     9,    90,    90,    88,    85,    82,    78,    73,    67,    61,    54,    46,    38,    31,    22,    13,     4)
    };
    #define DEFINE_DCT4x4_MATRIX(a,b,c) \
    { \
      { a,  a,  a,  a}, \
      { b,  c, -c, -b}, \
      { a, -a, -a,  a}, \
      { c, -b,  b, -c}  \
    }
    
    #define DEFINE_DCT8x8_MATRIX(a,b,c,d,e,f,g) \
    { \
      { a,  a,  a,  a,  a,  a,  a,  a}, \
      { d,  e,  f,  g, -g, -f, -e, -d}, \
      { b,  c, -c, -b, -b, -c,  c,  b}, \
      { e, -g, -d, -f,  f,  d,  g, -e}, \
      { a, -a, -a,  a,  a, -a, -a,  a}, \
      { f, -d,  g,  e, -e, -g,  d, -f}, \
      { c, -b,  b, -c, -c,  b, -b,  c}, \
      { g, -f,  e, -d,  d, -e,  f, -g}  \
    }
    
    #define DEFINE_DCT16x16_MATRIX(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
    { \
      { a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a}, \
      { h,  i,  j,  k,  l,  m,  n,  o, -o, -n, -m, -l, -k, -j, -i, -h}, \
      { d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d}, \
      { i,  l,  o, -m, -j, -h, -k, -n,  n,  k,  h,  j,  m, -o, -l, -i}, \
      { b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b}, \
      { j,  o, -k, -i, -n,  l,  h,  m, -m, -h, -l,  n,  i,  k, -o, -j}, \
      { e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e}, \
      { k, -m, -i,  o,  h,  n, -j, -l,  l,  j, -n, -h, -o,  i,  m, -k}, \
      { a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a}, \
      { l, -j, -n,  h, -o, -i,  m,  k, -k, -m,  i,  o, -h,  n,  j, -l}, \
      { f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f}, \
      { m, -h,  l,  n, -i,  k,  o, -j,  j, -o, -k,  i, -n, -l,  h, -m}, \
      { c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c}, \
      { n, -k,  h, -j,  m,  o, -l,  i, -i,  l, -o, -m,  j, -h,  k, -n}, \
      { g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g}, \
      { o, -n,  m, -l,  k, -j,  i, -h,  h, -i,  j, -k,  l, -m,  n, -o}  \
    }
    
    #define DEFINE_DCT32x32_MATRIX(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E) \
    { \
      { a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a,  a}, \
      { p,  q,  r,  s,  t,  u,  v,  w,  x,  y,  z,  A,  B,  C,  D,  E, -E, -D, -C, -B, -A, -z, -y, -x, -w, -v, -u, -t, -s, -r, -q, -p}, \
      { h,  i,  j,  k,  l,  m,  n,  o, -o, -n, -m, -l, -k, -j, -i, -h, -h, -i, -j, -k, -l, -m, -n, -o,  o,  n,  m,  l,  k,  j,  i,  h}, \
      { q,  t,  w,  z,  C, -E, -B, -y, -v, -s, -p, -r, -u, -x, -A, -D,  D,  A,  x,  u,  r,  p,  s,  v,  y,  B,  E, -C, -z, -w, -t, -q}, \
      { d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d,  d,  e,  f,  g, -g, -f, -e, -d, -d, -e, -f, -g,  g,  f,  e,  d}, \
      { r,  w,  B, -D, -y, -t, -p, -u, -z, -E,  A,  v,  q,  s,  x,  C, -C, -x, -s, -q, -v, -A,  E,  z,  u,  p,  t,  y,  D, -B, -w, -r}, \
      { i,  l,  o, -m, -j, -h, -k, -n,  n,  k,  h,  j,  m, -o, -l, -i, -i, -l, -o,  m,  j,  h,  k,  n, -n, -k, -h, -j, -m,  o,  l,  i}, \
      { s,  z, -D, -w, -p, -v, -C,  A,  t,  r,  y, -E, -x, -q, -u, -B,  B,  u,  q,  x,  E, -y, -r, -t, -A,  C,  v,  p,  w,  D, -z, -s}, \
      { b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b,  b,  c, -c, -b, -b, -c,  c,  b}, \
      { t,  C, -y, -p, -x,  D,  u,  s,  B, -z, -q, -w,  E,  v,  r,  A, -A, -r, -v, -E,  w,  q,  z, -B, -s, -u, -D,  x,  p,  y, -C, -t}, \
      { j,  o, -k, -i, -n,  l,  h,  m, -m, -h, -l,  n,  i,  k, -o, -j, -j, -o,  k,  i,  n, -l, -h, -m,  m,  h,  l, -n, -i, -k,  o,  j}, \
      { u, -E, -t, -v,  D,  s,  w, -C, -r, -x,  B,  q,  y, -A, -p, -z,  z,  p,  A, -y, -q, -B,  x,  r,  C, -w, -s, -D,  v,  t,  E, -u}, \
      { e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e,  e, -g, -d, -f,  f,  d,  g, -e, -e,  g,  d,  f, -f, -d, -g,  e}, \
      { v, -B, -p, -C,  u,  w, -A, -q, -D,  t,  x, -z, -r, -E,  s,  y, -y, -s,  E,  r,  z, -x, -t,  D,  q,  A, -w, -u,  C,  p,  B, -v}, \
      { k, -m, -i,  o,  h,  n, -j, -l,  l,  j, -n, -h, -o,  i,  m, -k, -k,  m,  i, -o, -h, -n,  j,  l, -l, -j,  n,  h,  o, -i, -m,  k}, \
      { w, -y, -u,  A,  s, -C, -q,  E,  p,  D, -r, -B,  t,  z, -v, -x,  x,  v, -z, -t,  B,  r, -D, -p, -E,  q,  C, -s, -A,  u,  y, -w}, \
      { a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a,  a, -a, -a,  a}, \
      { x, -v, -z,  t,  B, -r, -D,  p, -E, -q,  C,  s, -A, -u,  y,  w, -w, -y,  u,  A, -s, -C,  q,  E, -p,  D,  r, -B, -t,  z,  v, -x}, \
      { l, -j, -n,  h, -o, -i,  m,  k, -k, -m,  i,  o, -h,  n,  j, -l, -l,  j,  n, -h,  o,  i, -m, -k,  k,  m, -i, -o,  h, -n, -j,  l}, \
      { y, -s, -E,  r, -z, -x,  t,  D, -q,  A,  w, -u, -C,  p, -B, -v,  v,  B, -p,  C,  u, -w, -A,  q, -D, -t,  x,  z, -r,  E,  s, -y}, \
      { f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f,  f, -d,  g,  e, -e, -g,  d, -f, -f,  d, -g, -e,  e,  g, -d,  f}, \
      { z, -p,  A,  y, -q,  B,  x, -r,  C,  w, -s,  D,  v, -t,  E,  u, -u, -E,  t, -v, -D,  s, -w, -C,  r, -x, -B,  q, -y, -A,  p, -z}, \
      { m, -h,  l,  n, -i,  k,  o, -j,  j, -o, -k,  i, -n, -l,  h, -m, -m,  h, -l, -n,  i, -k, -o,  j, -j,  o,  k, -i,  n,  l, -h,  m}, \
      { A, -r,  v, -E, -w,  q, -z, -B,  s, -u,  D,  x, -p,  y,  C, -t,  t, -C, -y,  p, -x, -D,  u, -s,  B,  z, -q,  w,  E, -v,  r, -A}, \
      { c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c,  c, -b,  b, -c, -c,  b, -b,  c}, \
      { B, -u,  q, -x,  E,  y, -r,  t, -A, -C,  v, -p,  w, -D, -z,  s, -s,  z,  D, -w,  p, -v,  C,  A, -t,  r, -y, -E,  x, -q,  u, -B}, \
      { n, -k,  h, -j,  m,  o, -l,  i, -i,  l, -o, -m,  j, -h,  k, -n, -n,  k, -h,  j, -m, -o,  l, -i,  i, -l,  o,  m, -j,  h, -k,  n}, \
      { C, -x,  s, -q,  v, -A, -E,  z, -u,  p, -t,  y, -D, -B,  w, -r,  r, -w,  B,  D, -y,  t, -p,  u, -z,  E,  A, -v,  q, -s,  x, -C}, \
      { g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g,  g, -f,  e, -d,  d, -e,  f, -g, -g,  f, -e,  d, -d,  e, -f,  g}, \
      { D, -A,  x, -u,  r, -p,  s, -v,  y, -B,  E,  C, -z,  w, -t,  q, -q,  t, -w,  z, -C, -E,  B, -y,  v, -s,  p, -r,  u, -x,  A, -D}, \
      { o, -n,  m, -l,  k, -j,  i, -h,  h, -i,  j, -k,  l, -m,  n, -o, -o,  n, -m,  l, -k,  j, -i,  h, -h,  i, -j,  k, -l,  m, -n,  o}, \
      { E, -D,  C, -B,  A, -z,  y, -x,  w, -v,  u, -t,  s, -r,  q, -p,  p, -q,  r, -s,  t, -u,  v, -w,  x, -y,  z, -A,  B, -C,  D, -E}  \
    }

    DCT蝶形算法

    由于上面的DCT矩阵有很强的规律性,所有可以使用蝶形算法加快计算速度。下面以4x4的矩阵为例讲解蝶形算法。

    进行4x4DCT变换的计算过程如下:

    其中要进行4x4DCT矩阵和待变换矩阵X相乘的运算,由于4x4DCT矩阵是固定的,且有很强的规律性所以该矩阵相乘运算可以设计快速算法完成。

    可以看到上面矩阵运算过程中有多处进行了重复计算,可以在矩阵相乘前先计算出这些重复值从而避免多次计算,这就是蝶形算法。对于8x8、16x16和32x32矩阵蝶形算法类似。

    下面是HM中4x4DCT矩阵的蝶形算法:

    Void partialButterfly4(TCoeff *src, TCoeff *dst, Int shift, Int line)
    {
      Int j;
      TCoeff E[2],O[2];
      TCoeff add = (shift > 0) ? (1<<(shift-1)) : 0;
    
      for (j=0; j<line; j++)
      {
        /* E and O */
        E[0] = src[0] + src[3];
        O[0] = src[0] - src[3];
        E[1] = src[1] + src[2];
        O[1] = src[1] - src[2];
    
        dst[0]      = (g_aiT4[TRANSFORM_FORWARD][0][0]*E[0] + g_aiT4[TRANSFORM_FORWARD][0][1]*E[1] + add)>>shift;
        dst[2*line] = (g_aiT4[TRANSFORM_FORWARD][2][0]*E[0] + g_aiT4[TRANSFORM_FORWARD][2][1]*E[1] + add)>>shift;
        dst[line]   = (g_aiT4[TRANSFORM_FORWARD][1][0]*O[0] + g_aiT4[TRANSFORM_FORWARD][1][1]*O[1] + add)>>shift;
        dst[3*line] = (g_aiT4[TRANSFORM_FORWARD][3][0]*O[0] + g_aiT4[TRANSFORM_FORWARD][3][1]*O[1] + add)>>shift;
    
        src += 4;
        dst ++;
      }
    }

    感兴趣的请关注微信公众号Video Coding

     

    展开全文
  • 使用matlab编程蝶形算法,从原理到代码,讲解的很详细,此算法优点是速度块,精度可控,因此比傅里叶变换使用的更加广泛,适合随机振动方向的科研工作者学习参考,有问题可以私信,有问必答,欢迎你的购买
  • 数字信号处理--FFT与蝶形算法--学习笔记

    千次阅读 多人点赞 2019-09-17 22:18:07
    数字信号处理–FFT与蝶形算法 FFT是DTF的一种快速算法,利用了旋转因子的特效对DFT进行了化简,大大的减少了计算量. 旋转因子的特性 对称性 周期性 可约性 推论 基-2 FFT算法推导 1.将序列分解成奇数序列和...

    数字信号处理–FFT与蝶形算法

    FFT是DTF的一种快速算法,利用了旋转因子的特效对DFT进行了化简,大大的减少了计算量.

    在这里插入图片描述

    旋转因子的特性

    • 对称性
      在这里插入图片描述
    • 周期性
      在这里插入图片描述
    • 可约性
      在这里插入图片描述
    • 推论
      在这里插入图片描述

    基-2 FFT算法推导

    1.将序列分解成奇数序列和偶数序列.

    在这里插入图片描述

    2.化简

    • 将N个元素的序列拆分为两个N/2个元素的序列
    • 将旋转因子的指数的分子和分母同时除以2
    • 将第二项的旋转因子抽出,使旋转因子指数相同
    • 化简后的式子k的取值范围为0~(N/2)-1,因为取值超过(N/2)-1会超出分解后的序列长度
      在这里插入图片描述
      在这里插入图片描述在这里插入图片描述
      在这里插入图片描述

    3.计算后半序列(N/2)

    为了计算N/2之后的序列,使k+(N/2)
    后半序列和前半序列的值相等,但旋转因子的符号不同,化简过程中利用了旋转因子的特性.
    在这里插入图片描述

    参考

    在这里插入图片描述

    蝶形运算式

    综合以上推导我们可以得到如下结论:一个N点的DFT变换过程可以用两个N/2点的DFT变换过程来表示
    在这里插入图片描述

    8点DFT的4点分解

    在这里插入图片描述

    8点DFT的2点分解

    在这里插入图片描述
    在这里插入图片描述

    参考文献:
    https://www.cnblogs.com/luoqingyu/p/5930181.html
    https://max.book118.com/html/2019/0107/8116053027002000.shtm

    展开全文
  • 89C51FFT(蝶形算法

    2009-12-24 14:07:06
    基于8051单片机的快速傅里叶变换,应用蝶形算法,降低成本,已试过无问题!!
  • 【signal】傅里叶分析和FFT蝶形算法

    千次阅读 2018-10-31 18:56:01
    Date: 2018.10.31 下面两篇文章对傅里叶分析和FFT蝶形算法的分析很好,特转载。 https://www.cnblogs.com/luoqingyu/p/5930181.html https://zhuanlan.zhihu.com/p/19763358

    Date: 2018.10.31


    下面两篇文章对傅里叶分析和FFT蝶形算法的分析很好,特转载。

    https://www.cnblogs.com/luoqingyu/p/5930181.html
    https://zhuanlan.zhihu.com/p/19763358

    展开全文
  • 第五章 快速傅里叶变换;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;35;36;37;38;39;40;41;42;43;44;45;46;47;48;49;50;51;52;53
  • H.264整数DCT公式推导及蝶形算法分析

    千次阅读 2016-05-06 11:17:05
    这篇文章对DCT公式推导和蝶形算法的分析写的比较清晰,所有就转载过来,转载地址: http://www.cnblogs.com/xkfz007/archive/2012/07/31/2616791.html 1.为什么要进行变换  空间图像数据通常是很难压缩...

    这篇文章对DCT公式推导和蝶形算法的分析写的比较清晰,所有就转载过来,转载地址:

    http://www.cnblogs.com/xkfz007/archive/2012/07/31/2616791.html

    1.为什么要进行变换

        空间图像数据通常是很难压缩的:相邻的采样点具有很强的相关性(相互关联的),而且能量一般平均分布在一幅图像中,从而要想丢掉某些数据和降低数据精度而不明显影响图像质量,就要选择合适的变换,方法,使图像易于被压缩。适合压缩的变换方法要有这样几个性质:

    (1).可以聚集图像的能量(将能量集中到少数有意义的数值上),如下图:


    举个例子说明, 左图是变换前的数据, 右图是变换后的数据:


    可以看出,经变换后,数据的能量基本上集中到左上方(低频信号)了,而变换后的数据完全可以通过反变换还原成原来的数据。为了达到压缩文件的目的,我们就可以丢弃掉一些能量低的数据(高频信号),而对图像质量影响很小。

    1. 可以除去数据之间的相关性(以使丢掉不重要的数据对图像的质量影响很少)。
    2. 变换方法应该适合用软硬件实现。
    2.具体变换过程
       4x4的DCT变换矩阵如下:

    这样我们就得到了,如下矩阵:

    进行推导得到如下:

    在上式中, 虽然乘以 1/2 的操作可以用右移来实现 , 但这样会产生截断误差 . 因此, 将1/2提到矩阵外面, 并与右边的点乘合并, 进而得到如下的算式:

    在JM编码器中,变换过程只包括了

    后面的点乘实际上是在量化过程中进行,因为后面的点乘还有实数运算,实数运算将不可避免地产生精度误差,而且运算量巨大。而量化本身就会丢失一些信号,因些,这些实数运算放在量化过程中将大大的降低变换的运算率同时又不明显影响精度。

    然而,4X4的矩阵运算如果按常规算法的话仍要进行64次乘法运算和48次加法,这将耗费较多的时间,于是在H.264中,有一种改进的 算法(蝶形算法)可以减少运算的次数。这种矩阵运算算法构造非常巧妙,利用构造的矩阵的整数性质和对称性,可完全将乘法运算转化为加法运算。

    这里来分析一下蝶形算法,这个蝶形算法和一般FFT的蝶形算法不同,由于我没有找到相关论文,能找到的书和网络资料又语焉不详,只好自己推导。上面的JM代码就是计算下面三个4x4矩阵的过程。

    分析一下前两个矩阵的乘法,只分析他们结果矩阵的第一列。有什么办法可以减少运算量呢?首先采用传统方法计算,得到结果:

    X[0] = x[00]+x[10]+x[20]+x[30]

    X[1] = 2*x[00]+x[10]-x[20]-2*x[30]

    X[2]= x[00]-x[10]-x[20]+x[30]

    X[3] = x[00]-2x[10]+2x[20]-x[30]

    计算代价是16次乘法12次加法,考虑到矩阵的1的乘法可以省略,去除8个乘1,还需要8次乘法和12次加法。那么我们再仔细思考他们的相 关性,从一般算法意义上来说,可以用空间代价换时间代价,比如设置中间变量来减少计算次数。用不同的颜色把需要重复运算的部分标上,作为中间变量。

    X[0] = x[00]+x[10]+x[20]+x[30]

    X[1] = 2*x[00]+x[10]-x[20]-2*x[30]

    X[2]= x[00]-x[10]-x[20]+x[30]

    X[3] = x[00]-2x[10]+2x[20]-x[30]

    那么提取出来的中间变量将是:

    x[00]+x[30]

    x[00]-x[30]

    x[10]+x[20]

    x[10]-x[20]

    存储了这四个中间变量,我们对比看看蝶形图,和图中第一层的算式相符合。用这些中间变量来组合,就可以把最终的X[0]..X[3], 计算出来。这样,就把运算量降低到2个乘法和8个加法,剩余的运算就是叠代这个算法。

    所以,可以得出以下结论:

    1. 这个蝶形图和一般意义的FFT或FDCT蝶形图不同,是对H.264在整数DCT基础上的具体算法优化,只对于以上Cf矩阵。
    2. 计算过程是把上面的三个4x4矩阵乘法分成两两矩阵相乘。再把残差矩阵和后来的中间结果Cf x X一行行分别输入蝶形图进行一维整数DCT计算。
    3. 蝶形图优化思想就是提取矩阵的相关部分,定义中间变量,减少运算次数。

    在JM8.6代码中这个碟形算法, 出现的地方很多, 只要牵扯到变换, 就有这种算法. 包括Hadamard变换. 在多个函数中出现, 其实现是一样的。

    H.264中DCT变换中所使用到的蝶形算法描述:

    然而,4x4的矩阵运算如果按常规算法的话仍要进行64次乘法运算和48次加法运算,这将耗费较多的时间,于是在H.264中有一种改进的算法(蝶形算法)可以改进运算的次数,这种矩阵运算算法构造非常巧妙,利用构造的矩阵的整数性质和对称性,可完全将乘法运算转化加法运算。



    变换过程在JM中的代码实现如下:

    // Horizontal transform水平变换,其实就是左乘Cf,
    for (j=0; j < BLOCK_SIZE && !lossless_qpprime; j++)
    {
        for (i=0; i < 2; i++)
    {
    i1=3-i;
    m5[i]=img->m7[i][j]+img->m7[i1][j];
    m5[i1]=img->m7[i][j]-img->m7[i1][j];
    }
    img->m7[0][j]=(m5[0]+m5[1]);
    img->m7[2][j]=(m5[0]-m5[1]);
    img->m7[1][j]=m5[3]*2+m5[2];
    img->m7[3][j]=m5[3]-m5[2]*2;
    }
    
    // Vertical transform垂直变换,其实就是右乘CfT
    for (i=0; i < BLOCK_SIZE && !lossless_qpprime; i++)
    {
        for (j=0; j < 2; j++)
    {
    j1=3-j;
    m5[j]=img->m7[i][j]+img->m7[i][j1];
    m5[j1]=img->m7[i][j]-img->m7[i][j1];
    }
    img->m7[i][0]=(m5[0]+m5[1]);
    img->m7[i][2]=(m5[0]-m5[1]);
    img->m7[i][1]=m5[3]*2+m5[2];
    img->m7[i][3]=m5[3]-m5[2]*2;
    
    }
    展开全文
  • 31 观察原位运算规律 32 蝶形运算两节点间的距离 以 N=8 为例 第一级蝶形距离为 第二级蝶形距离为 第三级蝶形距离为 规律 对于共 L 级的蝶形而言其 m 级蝶形运算的节 点间的距离为 1 2 4 1 2 ? m ? 蝶形运算两节点间...
  • 这几天在网上查阅资料,研究了几天的...算法依据原理可参照以下文章:FFT快速傅里叶变换(蝶形算法)详解  以下就分享一下代码咯,思路都体现在源程序的本身结构和注释中。 点击此处直接下载所有代码 part 1,myf...
  • 第4章 快速傅立叶变换 问题的提出 解决问题的思路与方法 基2时间抽取FFT算法 基2时间抽取FFT算法的计算复杂度 基2时间抽取FFT算法流图规律 基2频率抽取FFT算法 FFT算法的实际应用 问题的提出 解决问题的思路 旋转...
  • 蝶形算法(H.264)

    千次阅读 2011-03-17 22:57:00
    蝶形算法(H.264) 视频编码2009-10-27 09:01:15阅读379评论0 字号:大中小 订阅    为什么要进行变换 空间图像数据通常是很难压缩的:相邻的采样点具有很强的相关性(相互关联的),而且...
  • Cooley-Tukey算法差别于其它FFT算法的一个重要事实就是N的因子能够随意选取。这样也就能够使用N=rS... S>2时的-个一般惯例是,在信号流程图中2点DFT是以蝶形图的形式绘出的,图1给出了8点变换的图示。信号流程...
  • 5.1 引言 DFT在实际应用中很重要: 可以计算信号的频谱功率谱和线性卷积等 直接按DFT变换进行计算当序列长度N很大时计算量非常大所需时间会很长 FFT并不是一种与DFT不同的变换而是DFT的一种快速计算的算法 ...
  • DCT 离散余弦变换及蝶形算法

    千次阅读 2019-05-09 17:54:19
    在压缩算法中,将输入图像划分为8 8或16 16的图像块,对每个图像块作DCT变换(分块后,每个块较小,运算时间更短);然后舍弃高频的系数,并对余下的系数进行量化以进一步减少数据量;最后使用无失真编码来完成压缩...
  • 数字信号处理--FFT与蝶形算法

    千次阅读 2019-09-22 19:12:51
    尽管传统的DFT算法能够获取信号频域特征,但是算法计算量大,耗时长,不利于计算机实时对信号进行处理。因此至DFT被发现以来,在很长的一段时间内都不能被应用到实际的工程项目中,直到一种快速的离散傅立叶计算方法...
  • fft蝶形算法的特点

    2014-11-26 14:59:00
    转载于:https://www.cnblogs.com/lianjiehere/p/4123266.html
  • FFT的运算过程详细介绍,并且包含DIT-FFT和DIF-FFT的两种FFT介绍
  • FFT蝶形算法,IFFT

    千次阅读 2011-01-14 16:15:00
    //FFT蝶形算法 //xt为原数据,cur_x为最后所求的数据,nex_x为中间变量 void FFT( comp_num xt[N], comp_num cur_x[N], comp_num nex_x[N]) {  int i,j,k;  int t,wn;  double x;  comp_num W,sec;//蝶形运算的第...
  • 从图1中,我们可以看得出,FFT蝶形算法会使用三重循环,下一层的数据都是由上一层计算得到的。这里直接在代码里面备注一下,比较好解释的。 for(i = 0; i ; i++)//第一重循环k=log2N,在这里N = 8,所以k = 2 {...
  • 快速傅里叶变换(蝶形算法

    千次阅读 2013-12-04 19:54:27
    一、傅里叶变换  傅里叶变换能将满足一定条件的某个函数表示成三角函数或是它们的积分的线性组合... 2、FFT中常用的蝶形算法  

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,002
精华内容 800
关键字:

蝶形算法