开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
transform.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：12k
源码类别：

Audio

开发平台：

Visual C++

transform.c：源码内容
  1. /*!
  2.  ***************************************************************************
  3.  * file transform.c
  4.  *
  5.  * brief
  6.  *    Transform functions
  7.  *
  8.  * author
  9.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  10.  *    - Alexis Michael Tourapis
  11.  * date
  12.  *    01. July 2007
  13.  **************************************************************************
  14.  */
  16. #include "global.h"
  17. #include "transform.h"
  20. static int tmp[64];
  22. void forward4x4(int (*block)[16], int (*tblock)[16], int pos_y, int pos_x)
  23. {
  24.   int i, ii;  
  25.   int *pTmp = tmp, *pblock;
  26.   static int p0,p1,p2,p3;
  27.   static int t0,t1,t2,t3;
  29.   // Horizontal
  30.   for (i=pos_y; i < pos_y + BLOCK_SIZE; i++)
  31.   {
  32.     pblock = &block[i][pos_x];
  33.     p0 = *(pblock++);
  34.     p1 = *(pblock++);
  35.     p2 = *(pblock++);
  36.     p3 = *(pblock  );
  38.     t0 = p0 + p3;
  39.     t1 = p1 + p2;
  40.     t2 = p1 - p2;
  41.     t3 = p0 - p3;
  43.     *(pTmp++) =  t0 + t1;
  44.     *(pTmp++) = (t3 << 1) + t2;
  45.     *(pTmp++) =  t0 - t1;    
  46.     *(pTmp++) =  t3 - (t2 << 1);
  47.   }
  49.   // Vertical 
  50.   for (i=0; i < BLOCK_SIZE; i++)
  51.   {
  52.     pTmp = tmp + i;
  53.     p0 = *pTmp;
  54.     p1 = *(pTmp += BLOCK_SIZE);
  55.     p2 = *(pTmp += BLOCK_SIZE);
  56.     p3 = *(pTmp += BLOCK_SIZE);
  58.     t0 = p0 + p3;
  59.     t1 = p1 + p2;
  60.     t2 = p1 - p2;
  61.     t3 = p0 - p3;
  63.     ii = pos_x + i;
  64.     tblock[pos_y    ][ii] = t0 +  t1;
  65.     tblock[pos_y + 1][ii] = t2 + (t3 << 1);
  66.     tblock[pos_y + 2][ii] = t0 -  t1;
  67.     tblock[pos_y + 3][ii] = t3 - (t2 << 1);
  68.   }
  69. }
  72. void inverse4x4(int (*tblock)[16], int (*block)[16], int pos_y, int pos_x)
  73. {
  74.   int i, ii;  
  75.   int *pTmp = tmp, *pblock;
  76.   static int p0,p1,p2,p3;
  77.   static int t0,t1,t2,t3;
  79.   // Horizontal
  80.   for (i = pos_y; i < pos_y + BLOCK_SIZE; i++)
  81.   {
  82.     pblock = &tblock[i][pos_x];
  83.     t0 = *(pblock++);
  84.     t1 = *(pblock++);
  85.     t2 = *(pblock++);
  86.     t3 = *(pblock  );
  88.     p0 =  t0 + t2;
  89.     p1 =  t0 - t2;
  90.     p2 = (t1 >> 1) - t3;
  91.     p3 =  t1 + (t3 >> 1);
  93.     *(pTmp++) = p0 + p3;
  94.     *(pTmp++) = p1 + p2;
  95.     *(pTmp++) = p1 - p2;
  96.     *(pTmp++) = p0 - p3;
  97.   }
  99.   //  Vertical 
  100.   for (i = 0; i < BLOCK_SIZE; i++)
  101.   {
  102.     pTmp = tmp + i;
  103.     t0 = *pTmp;
  104.     t1 = *(pTmp += BLOCK_SIZE);
  105.     t2 = *(pTmp += BLOCK_SIZE);
  106.     t3 = *(pTmp += BLOCK_SIZE);
  108.     p0 = t0 + t2;
  109.     p1 = t0 - t2;
  110.     p2 =(t1 >> 1) - t3;
  111.     p3 = t1 + (t3 >> 1);
  113.     ii = i + pos_x;
  114.     block[pos_y    ][ii] = p0 + p3;
  115.     block[pos_y + 1][ii] = p1 + p2;
  116.     block[pos_y + 2][ii] = p1 - p2;
  117.     block[pos_y + 3][ii] = p0 - p3;
  118.   }
  119. }
  122. void hadamard4x4(int (*block)[4], int (*tblock)[4])
  123. {
  124.   int i;
  125.   int *pTmp = tmp, *pblock;
  126.   static int p0,p1,p2,p3;
  127.   static int t0,t1,t2,t3;
  129.   // Horizontal
  130.   for (i = 0; i < BLOCK_SIZE; i++)
  131.   {
  132.     pblock = block[i];
  133.     p0 = *(pblock++);
  134.     p1 = *(pblock++);
  135.     p2 = *(pblock++);
  136.     p3 = *(pblock  );
  138.     t0 = p0 + p3;
  139.     t1 = p1 + p2;
  140.     t2 = p1 - p2;
  141.     t3 = p0 - p3;
  143.     *(pTmp++) = t0 + t1;
  144.     *(pTmp++) = t3 + t2;
  145.     *(pTmp++) = t0 - t1;    
  146.     *(pTmp++) = t3 - t2;
  147.   }
  149.   // Vertical 
  150.   for (i = 0; i < BLOCK_SIZE; i++)
  151.   {
  152.     pTmp = tmp + i;
  153.     p0 = *pTmp;
  154.     p1 = *(pTmp += BLOCK_SIZE);
  155.     p2 = *(pTmp += BLOCK_SIZE);
  156.     p3 = *(pTmp += BLOCK_SIZE);
  158.     t0 = p0 + p3;
  159.     t1 = p1 + p2;
  160.     t2 = p1 - p2;
  161.     t3 = p0 - p3;
  163.     tblock[0][i] = (t0 + t1) >> 1;
  164.     tblock[1][i] = (t2 + t3) >> 1;
  165.     tblock[2][i] = (t0 - t1) >> 1;
  166.     tblock[3][i] = (t3 - t2) >> 1;
  167.   }
  168. }
  171. void ihadamard4x4(int (*tblock)[4], int (*block)[4])
  172. {
  173.   int i;  
  174.   int *pTmp = tmp, *pblock;
  175.   static int p0,p1,p2,p3;
  176.   static int t0,t1,t2,t3;
  178.   // Horizontal
  179.   for (i = 0; i < BLOCK_SIZE; i++)
  180.   {
  181.     pblock = tblock[i];
  182.     t0 = *(pblock++);
  183.     t1 = *(pblock++);
  184.     t2 = *(pblock++);
  185.     t3 = *(pblock  );
  187.     p0 = t0 + t2;
  188.     p1 = t0 - t2;
  189.     p2 = t1 - t3;
  190.     p3 = t1 + t3;
  192.     *(pTmp++) = p0 + p3;
  193.     *(pTmp++) = p1 + p2;
  194.     *(pTmp++) = p1 - p2;
  195.     *(pTmp++) = p0 - p3;
  196.   }
  198.   //  Vertical 
  199.   for (i = 0; i < BLOCK_SIZE; i++)
  200.   {
  201.     pTmp = tmp + i;
  202.     t0 = *pTmp;
  203.     t1 = *(pTmp += BLOCK_SIZE);
  204.     t2 = *(pTmp += BLOCK_SIZE);
  205.     t3 = *(pTmp += BLOCK_SIZE);
  207.     p0 = t0 + t2;
  208.     p1 = t0 - t2;
  209.     p2 = t1 - t3;
  210.     p3 = t1 + t3;
  211.     
  212.     block[0][i] = p0 + p3;
  213.     block[1][i] = p1 + p2;
  214.     block[2][i] = p1 - p2;
  215.     block[3][i] = p0 - p3;
  216.   }
  217. }
  219. void hadamard4x2(int (*block)[4], int (*tblock)[4])
  220. {
  221.   int i;
  222.   int *pTmp = tmp;
  223.   static int p0,p1,p2,p3;
  224.   static int t0,t1,t2,t3;
  226.   // Horizontal
  227.   *(pTmp++) = block[0][0] + block[1][0];
  228.   *(pTmp++) = block[0][1] + block[1][1];
  229.   *(pTmp++) = block[0][2] + block[1][2];
  230.   *(pTmp++) = block[0][3] + block[1][3];
  232.   *(pTmp++) = block[0][0] - block[1][0];
  233.   *(pTmp++) = block[0][1] - block[1][1];
  234.   *(pTmp++) = block[0][2] - block[1][2];
  235.   *(pTmp  ) = block[0][3] - block[1][3];
  237.   // Vertical
  238.   pTmp = tmp;
  239.   for (i=0;i<2;i++)
  240.   {      
  241.     p0 = *(pTmp++);
  242.     p1 = *(pTmp++);
  243.     p2 = *(pTmp++);
  244.     p3 = *(pTmp++);
  246.     t0 = p0 + p3;
  247.     t1 = p1 + p2;
  248.     t2 = p1 - p2;
  249.     t3 = p0 - p3;
  251.     tblock[i][0] = (t0 + t1);
  252.     tblock[i][1] = (t3 + t2);
  253.     tblock[i][2] = (t0 - t1);      
  254.     tblock[i][3] = (t3 - t2);
  255.   }
  256. }
  258. void ihadamard4x2(int (*tblock)[4], int (*block)[4])
  259. {
  260.   int i;  
  261.   int *pTmp = tmp;
  262.   static int p0,p1,p2,p3;
  263.   static int t0,t1,t2,t3;
  265.   // Horizontal
  266.   *(pTmp++) = tblock[0][0] + tblock[1][0];
  267.   *(pTmp++) = tblock[0][1] + tblock[1][1];
  268.   *(pTmp++) = tblock[0][2] + tblock[1][2];
  269.   *(pTmp++) = tblock[0][3] + tblock[1][3];
  271.   *(pTmp++) = tblock[0][0] - tblock[1][0];
  272.   *(pTmp++) = tblock[0][1] - tblock[1][1];
  273.   *(pTmp++) = tblock[0][2] - tblock[1][2];
  274.   *(pTmp  ) = tblock[0][3] - tblock[1][3];
  276.   // Vertical
  277.   pTmp = tmp;
  278.   for (i = 0; i < 2; i++)
  279.   {
  280.     p0 = *(pTmp++);
  281.     p1 = *(pTmp++);
  282.     p2 = *(pTmp++);
  283.     p3 = *(pTmp++);
  285.     t0 = p0 + p2;
  286.     t1 = p0 - p2;
  287.     t2 = p1 - p3;
  288.     t3 = p1 + p3;
  290.     // coefficients (transposed)
  291.     block[0][i] = t0 + t3;
  292.     block[1][i] = t1 + t2;
  293.     block[2][i] = t1 - t2;
  294.     block[3][i] = t0 - t3;
  295.   }
  296. }
  298. //following functions perform 8 additions, 8 assignments. Should be a bit faster
  299. void hadamard2x2(int (*block)[16], int tblock[4])
  300. {
  301.   static int p0,p1,p2,p3;
  303.   p0 = block[0][0] + block[0][4];
  304.   p1 = block[0][0] - block[0][4];
  305.   p2 = block[4][0] + block[4][4];
  306.   p3 = block[4][0] - block[4][4];
  307.  
  308.   tblock[0] = (p0 + p2);
  309.   tblock[1] = (p1 + p3);
  310.   tblock[2] = (p0 - p2);
  311.   tblock[3] = (p1 - p3);
  312. }
  314. void ihadamard2x2(int tblock[4], int block[4])
  315. {
  316.   static int t0,t1,t2,t3;
  318.   t0 = tblock[0] + tblock[1];
  319.   t1 = tblock[0] - tblock[1];
  320.   t2 = tblock[2] + tblock[3];
  321.   t3 = tblock[2] - tblock[3];
  323.   block[0] = (t0 + t2);
  324.   block[1] = (t1 + t3);
  325.   block[2] = (t0 - t2);
  326.   block[3] = (t1 - t3);
  327. }
  329. /*
  330. void hadamard2x2(int (*block)[16], int tblock[4])
  331. {
  332.   //12 additions, 4 assignments
  333.     tblock[0] = (block[0][0] + block[0][4] + block[4][0] + block[4][4]);
  334.     tblock[1] = (block[0][0] - block[0][4] + block[4][0] - block[4][4]);
  335.     tblock[2] = (block[0][0] + block[0][4] - block[4][0] - block[4][4]);
  336.     tblock[3] = (block[0][0] - block[0][4] - block[4][0] + block[4][4]);
  337. }
  339. void ihadamard2x2(int tblock[4], int block[4])
  340. {
  341.     block[0] = (tblock[0] + tblock[1] + tblock[2] + tblock[3]);
  342.     block[1] = (tblock[0] - tblock[1] + tblock[2] - tblock[3]);
  343.     block[2] = (tblock[0] + tblock[1] - tblock[2] - tblock[3]);
  344.     block[3] = (tblock[0] - tblock[1] - tblock[2] + tblock[3]);
  345. }
  347. */
  350. void forward8x8(int (*block)[16], int (*tblock)[16], int pos_y, int pos_x)
  351. {
  352.   int i, ii;  
  353.   int *pTmp = tmp, *pblock;
  354.   static int a0, a1, a2, a3;
  355.   static int p0, p1, p2, p3, p4, p5 ,p6, p7;
  356.   static int b0, b1, b2, b3, b4, b5, b6, b7;
  358.   // Horizontal
  359.   for (i=pos_y; i < pos_y + BLOCK_SIZE_8x8; i++)
  360.   {
  361.     pblock = &block[i][pos_x];
  362.     p0 = *(pblock++);
  363.     p1 = *(pblock++);
  364.     p2 = *(pblock++);
  365.     p3 = *(pblock++);
  366.     p4 = *(pblock++);
  367.     p5 = *(pblock++);
  368.     p6 = *(pblock++);
  369.     p7 = *(pblock  );
  371.     a0 = p0 + p7;
  372.     a1 = p1 + p6;
  373.     a2 = p2 + p5;
  374.     a3 = p3 + p4;
  376.     b0 = a0 + a3;
  377.     b1 = a1 + a2;
  378.     b2 = a0 - a3;
  379.     b3 = a1 - a2;
  381.     a0 = p0 - p7;
  382.     a1 = p1 - p6;
  383.     a2 = p2 - p5;
  384.     a3 = p3 - p4;
  386.     b4 = a1 + a2 + ((a0 >> 1) + a0);
  387.     b5 = a0 - a3 - ((a2 >> 1) + a2);
  388.     b6 = a0 + a3 - ((a1 >> 1) + a1);
  389.     b7 = a1 - a2 + ((a3 >> 1) + a3);
  391.     *(pTmp++) =  b0 + b1;
  392.     *(pTmp++) =  b4 + (b7 >> 2);
  393.     *(pTmp++) =  b2 + (b3 >> 1);
  394.     *(pTmp++) =  b5 + (b6 >> 2);
  395.     *(pTmp++) =  b0 - b1;
  396.     *(pTmp++) =  b6 - (b5 >> 2);
  397.     *(pTmp++) = (b2 >> 1) - b3;                 
  398.     *(pTmp++) = (b4 >> 2) - b7;
  399.   }
  401.   // Vertical 
  402.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  403.   {
  404.     pTmp = tmp + i;
  405.     p0 = *pTmp;
  406.     p1 = *(pTmp += BLOCK_SIZE_8x8);
  407.     p2 = *(pTmp += BLOCK_SIZE_8x8);
  408.     p3 = *(pTmp += BLOCK_SIZE_8x8);
  409.     p4 = *(pTmp += BLOCK_SIZE_8x8);
  410.     p5 = *(pTmp += BLOCK_SIZE_8x8);
  411.     p6 = *(pTmp += BLOCK_SIZE_8x8);
  412.     p7 = *(pTmp += BLOCK_SIZE_8x8);
  414.     a0 = p0 + p7;
  415.     a1 = p1 + p6;
  416.     a2 = p2 + p5;
  417.     a3 = p3 + p4;
  419.     b0 = a0 + a3;
  420.     b1 = a1 + a2;
  421.     b2 = a0 - a3;
  422.     b3 = a1 - a2;
  424.     a0 = p0 - p7;
  425.     a1 = p1 - p6;
  426.     a2 = p2 - p5;
  427.     a3 = p3 - p4;
  429.     b4 = a1 + a2 + ((a0 >> 1) + a0);
  430.     b5 = a0 - a3 - ((a2 >> 1) + a2);
  431.     b6 = a0 + a3 - ((a1 >> 1) + a1);
  432.     b7 = a1 - a2 + ((a3 >> 1) + a3);
  434.     ii = pos_x + i;
  435.     tblock[pos_y    ][ii] =  b0 + b1;
  436.     tblock[pos_y + 1][ii] =  b4 + (b7 >> 2);
  437.     tblock[pos_y + 2][ii] =  b2 + (b3 >> 1);
  438.     tblock[pos_y + 3][ii] =  b5 + (b6 >> 2);
  439.     tblock[pos_y + 4][ii] =  b0 - b1;
  440.     tblock[pos_y + 5][ii] =  b6 - (b5 >> 2);
  441.     tblock[pos_y + 6][ii] = (b2 >> 1) - b3;
  442.     tblock[pos_y + 7][ii] = (b4 >> 2) - b7;
  443.   }
  444. }
  446. void inverse8x8(int (*tblock)[16], int (*block)[16], int pos_y, int pos_x)
  447. {
  448.   int i, ii;
  449.   int *pTmp = tmp, *pblock;
  450.   static int a0, a1, a2, a3;
  451.   static int p0, p1, p2, p3, p4, p5 ,p6, p7;  
  452.   static int b0, b1, b2, b3, b4, b5, b6, b7;
  454.   // Horizontal  
  455.   for (i=pos_y; i < pos_y + BLOCK_SIZE_8x8; i++)
  456.   {
  457.     pblock = &tblock[i][pos_x];
  458.     p0 = *(pblock++);
  459.     p1 = *(pblock++);
  460.     p2 = *(pblock++);
  461.     p3 = *(pblock++);
  462.     p4 = *(pblock++);
  463.     p5 = *(pblock++);
  464.     p6 = *(pblock++);
  465.     p7 = *(pblock  );
  467.     a0 = p0 + p4;
  468.     a1 = p0 - p4;
  469.     a2 = p6 - (p2 >> 1);
  470.     a3 = p2 + (p6 >> 1);
  472.     b0 =  a0 + a3;
  473.     b2 =  a1 - a2;
  474.     b4 =  a1 + a2;
  475.     b6 =  a0 - a3;
  477.     a0 = -p3 + p5 - p7 - (p7 >> 1);    
  478.     a1 =  p1 + p7 - p3 - (p3 >> 1);    
  479.     a2 = -p1 + p7 + p5 + (p5 >> 1);    
  480.     a3 =  p3 + p5 + p1 + (p1 >> 1);
  482.     
  483.     b1 =  a0 + (a3>>2);    
  484.     b3 =  a1 + (a2>>2);    
  485.     b5 =  a2 - (a1>>2);
  486.     b7 =  a3 - (a0>>2);                
  488.     *(pTmp++) = b0 + b7;
  489.     *(pTmp++) = b2 - b5;
  490.     *(pTmp++) = b4 + b3;
  491.     *(pTmp++) = b6 + b1;
  492.     *(pTmp++) = b6 - b1;
  493.     *(pTmp++) = b4 - b3;
  494.     *(pTmp++) = b2 + b5;
  495.     *(pTmp++) = b0 - b7;
  496.   }
  498.   //  Vertical 
  499.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  500.   {
  501.     pTmp = tmp + i;
  502.     p0 = *pTmp;
  503.     p1 = *(pTmp += BLOCK_SIZE_8x8);
  504.     p2 = *(pTmp += BLOCK_SIZE_8x8);
  505.     p3 = *(pTmp += BLOCK_SIZE_8x8);
  506.     p4 = *(pTmp += BLOCK_SIZE_8x8);
  507.     p5 = *(pTmp += BLOCK_SIZE_8x8);
  508.     p6 = *(pTmp += BLOCK_SIZE_8x8);
  509.     p7 = *(pTmp += BLOCK_SIZE_8x8);
  511.     a0 =  p0 + p4;
  512.     a1 =  p0 - p4;
  513.     a2 =  p6 - (p2>>1);
  514.     a3 =  p2 + (p6>>1);
  516.     b0 = a0 + a3;
  517.     b2 = a1 - a2;
  518.     b4 = a1 + a2;
  519.     b6 = a0 - a3;
  521.     a0 = -p3 + p5 - p7 - (p7 >> 1);
  522.     a1 =  p1 + p7 - p3 - (p3 >> 1);
  523.     a2 = -p1 + p7 + p5 + (p5 >> 1);
  524.     a3 =  p3 + p5 + p1 + (p1 >> 1);
  527.     b1 =  a0 + (a3 >> 2);
  528.     b7 =  a3 - (a0 >> 2);
  529.     b3 =  a1 + (a2 >> 2);
  530.     b5 =  a2 - (a1 >> 2);
  532.     ii = i + pos_x;
  533.     block[pos_y    ][ii] = b0 + b7;
  534.     block[pos_y + 1][ii] = b2 - b5;
  535.     block[pos_y + 2][ii] = b4 + b3;
  536.     block[pos_y + 3][ii] = b6 + b1;
  537.     block[pos_y + 4][ii] = b6 - b1;
  538.     block[pos_y + 5][ii] = b4 - b3;
  539.     block[pos_y + 6][ii] = b2 + b5;
  540.     block[pos_y + 7][ii] = b0 - b7;
  541.   }
  542. }