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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 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"
  19. static int tmp[64];
  21. void forward4x4(int (*block)[16], int (*tblock)[16], int pos_y, int pos_x)
  22. {
  23.   int i, ii;  
  24.   int *pTmp = tmp, *pblock;
  25.   static int p0,p1,p2,p3;
  26.   static int t0,t1,t2,t3;
  28.   // Horizontal
  29.   for (i=pos_y; i < pos_y + BLOCK_SIZE; i++)
  30.   {
  31.     pblock = &block[i][pos_x];
  32.     p0 = *(pblock++);
  33.     p1 = *(pblock++);
  34.     p2 = *(pblock++);
  35.     p3 = *(pblock  );
  37.     t0 = p0 + p3;
  38.     t1 = p1 + p2;
  39.     t2 = p1 - p2;
  40.     t3 = p0 - p3;
  42.     *(pTmp++) =  t0 + t1;
  43.     *(pTmp++) = (t3 << 1) + t2;
  44.     *(pTmp++) =  t0 - t1;    
  45.     *(pTmp++) =  t3 - (t2 << 1);
  46.   }
  48.   // Vertical 
  49.   for (i=0; i < BLOCK_SIZE; i++)
  50.   {
  51.     pTmp = tmp + i;
  52.     p0 = *pTmp;
  53.     p1 = *(pTmp += BLOCK_SIZE);
  54.     p2 = *(pTmp += BLOCK_SIZE);
  55.     p3 = *(pTmp += BLOCK_SIZE);
  57.     t0 = p0 + p3;
  58.     t1 = p1 + p2;
  59.     t2 = p1 - p2;
  60.     t3 = p0 - p3;
  62.     ii = pos_x + i;
  63.     tblock[pos_y    ][ii] = t0 +  t1;
  64.     tblock[pos_y + 1][ii] = t2 + (t3 << 1);
  65.     tblock[pos_y + 2][ii] = t0 -  t1;
  66.     tblock[pos_y + 3][ii] = t3 - (t2 << 1);
  67.   }
  68. }
  71. void inverse4x4(int (*tblock)[16], int (*block)[16], int pos_y, int pos_x)
  72. {
  73.   int i, ii;  
  74.   int *pTmp = tmp, *pblock;
  75.   static int p0,p1,p2,p3;
  76.   static int t0,t1,t2,t3;
  78.   // Horizontal
  79.   for (i = pos_y; i < pos_y + BLOCK_SIZE; i++)
  80.   {
  81.     pblock = &tblock[i][pos_x];
  82.     t0 = *(pblock++);
  83.     t1 = *(pblock++);
  84.     t2 = *(pblock++);
  85.     t3 = *(pblock  );
  87.     p0 =  t0 + t2;
  88.     p1 =  t0 - t2;
  89.     p2 = (t1 >> 1) - t3;
  90.     p3 =  t1 + (t3 >> 1);
  92.     *(pTmp++) = p0 + p3;
  93.     *(pTmp++) = p1 + p2;
  94.     *(pTmp++) = p1 - p2;
  95.     *(pTmp++) = p0 - p3;
  96.   }
  98.   //  Vertical 
  99.   for (i = 0; i < BLOCK_SIZE; i++)
  100.   {
  101.     pTmp = tmp + i;
  102.     t0 = *pTmp;
  103.     t1 = *(pTmp += BLOCK_SIZE);
  104.     t2 = *(pTmp += BLOCK_SIZE);
  105.     t3 = *(pTmp += BLOCK_SIZE);
  107.     p0 = t0 + t2;
  108.     p1 = t0 - t2;
  109.     p2 =(t1 >> 1) - t3;
  110.     p3 = t1 + (t3 >> 1);
  112.     ii = i + pos_x;
  113.     block[pos_y    ][ii] = p0 + p3;
  114.     block[pos_y + 1][ii] = p1 + p2;
  115.     block[pos_y + 2][ii] = p1 - p2;
  116.     block[pos_y + 3][ii] = p0 - p3;
  117.   }
  118. }
  121. void hadamard4x4(int (*block)[4], int (*tblock)[4])
  122. {
  123.   int i;
  124.   int *pTmp = tmp, *pblock;
  125.   static int p0,p1,p2,p3;
  126.   static int t0,t1,t2,t3;
  128.   // Horizontal
  129.   for (i = 0; i < BLOCK_SIZE; i++)
  130.   {
  131.     pblock = block[i];
  132.     p0 = *(pblock++);
  133.     p1 = *(pblock++);
  134.     p2 = *(pblock++);
  135.     p3 = *(pblock  );
  137.     t0 = p0 + p3;
  138.     t1 = p1 + p2;
  139.     t2 = p1 - p2;
  140.     t3 = p0 - p3;
  142.     *(pTmp++) = t0 + t1;
  143.     *(pTmp++) = t3 + t2;
  144.     *(pTmp++) = t0 - t1;    
  145.     *(pTmp++) = t3 - t2;
  146.   }
  148.   // Vertical 
  149.   for (i = 0; i < BLOCK_SIZE; i++)
  150.   {
  151.     pTmp = tmp + i;
  152.     p0 = *pTmp;
  153.     p1 = *(pTmp += BLOCK_SIZE);
  154.     p2 = *(pTmp += BLOCK_SIZE);
  155.     p3 = *(pTmp += BLOCK_SIZE);
  157.     t0 = p0 + p3;
  158.     t1 = p1 + p2;
  159.     t2 = p1 - p2;
  160.     t3 = p0 - p3;
  162.     tblock[0][i] = (t0 + t1) >> 1;
  163.     tblock[1][i] = (t2 + t3) >> 1;
  164.     tblock[2][i] = (t0 - t1) >> 1;
  165.     tblock[3][i] = (t3 - t2) >> 1;
  166.   }
  167. }
  170. void ihadamard4x4(int (*tblock)[4], int (*block)[4])
  171. {
  172.   int i;  
  173.   int *pTmp = tmp, *pblock;
  174.   static int p0,p1,p2,p3;
  175.   static int t0,t1,t2,t3;
  177.   // Horizontal
  178.   for (i = 0; i < BLOCK_SIZE; i++)
  179.   {
  180.     pblock = tblock[i];
  181.     t0 = *(pblock++);
  182.     t1 = *(pblock++);
  183.     t2 = *(pblock++);
  184.     t3 = *(pblock  );
  186.     p0 = t0 + t2;
  187.     p1 = t0 - t2;
  188.     p2 = t1 - t3;
  189.     p3 = t1 + t3;
  191.     *(pTmp++) = p0 + p3;
  192.     *(pTmp++) = p1 + p2;
  193.     *(pTmp++) = p1 - p2;
  194.     *(pTmp++) = p0 - p3;
  195.   }
  197.   //  Vertical 
  198.   for (i = 0; i < BLOCK_SIZE; i++)
  199.   {
  200.     pTmp = tmp + i;
  201.     t0 = *pTmp;
  202.     t1 = *(pTmp += BLOCK_SIZE);
  203.     t2 = *(pTmp += BLOCK_SIZE);
  204.     t3 = *(pTmp += BLOCK_SIZE);
  206.     p0 = t0 + t2;
  207.     p1 = t0 - t2;
  208.     p2 = t1 - t3;
  209.     p3 = t1 + t3;
  210.     
  211.     block[0][i] = p0 + p3;
  212.     block[1][i] = p1 + p2;
  213.     block[2][i] = p1 - p2;
  214.     block[3][i] = p0 - p3;
  215.   }
  216. }
  218. void hadamard4x2(int (*block)[4], int (*tblock)[4])
  219. {
  220.   int i;
  221.   int *pTmp = tmp;
  222.   static int p0,p1,p2,p3;
  223.   static int t0,t1,t2,t3;
  225.   // Horizontal
  226.   *(pTmp++) = block[0][0] + block[1][0];
  227.   *(pTmp++) = block[0][1] + block[1][1];
  228.   *(pTmp++) = block[0][2] + block[1][2];
  229.   *(pTmp++) = block[0][3] + block[1][3];
  231.   *(pTmp++) = block[0][0] - block[1][0];
  232.   *(pTmp++) = block[0][1] - block[1][1];
  233.   *(pTmp++) = block[0][2] - block[1][2];
  234.   *(pTmp  ) = block[0][3] - block[1][3];
  236.   // Vertical
  237.   pTmp = tmp;
  238.   for (i=0;i<2;i++)
  239.   {      
  240.     p0 = *(pTmp++);
  241.     p1 = *(pTmp++);
  242.     p2 = *(pTmp++);
  243.     p3 = *(pTmp++);
  245.     t0 = p0 + p3;
  246.     t1 = p1 + p2;
  247.     t2 = p1 - p2;
  248.     t3 = p0 - p3;
  250.     tblock[i][0] = (t0 + t1);
  251.     tblock[i][1] = (t3 + t2);
  252.     tblock[i][2] = (t0 - t1);      
  253.     tblock[i][3] = (t3 - t2);
  254.   }
  255. }
  257. void ihadamard4x2(int (*tblock)[4], int (*block)[4])
  258. {
  259.   int i;  
  260.   int *pTmp = tmp;
  261.   static int p0,p1,p2,p3;
  262.   static int t0,t1,t2,t3;
  264.   // Horizontal
  265.   *(pTmp++) = tblock[0][0] + tblock[1][0];
  266.   *(pTmp++) = tblock[0][1] + tblock[1][1];
  267.   *(pTmp++) = tblock[0][2] + tblock[1][2];
  268.   *(pTmp++) = tblock[0][3] + tblock[1][3];
  270.   *(pTmp++) = tblock[0][0] - tblock[1][0];
  271.   *(pTmp++) = tblock[0][1] - tblock[1][1];
  272.   *(pTmp++) = tblock[0][2] - tblock[1][2];
  273.   *(pTmp  ) = tblock[0][3] - tblock[1][3];
  275.   // Vertical
  276.   pTmp = tmp;
  277.   for (i = 0; i < 2; i++)
  278.   {
  279.     p0 = *(pTmp++);
  280.     p1 = *(pTmp++);
  281.     p2 = *(pTmp++);
  282.     p3 = *(pTmp++);
  284.     t0 = p0 + p2;
  285.     t1 = p0 - p2;
  286.     t2 = p1 - p3;
  287.     t3 = p1 + p3;
  289.     // coefficients (transposed)
  290.     block[0][i] = t0 + t3;
  291.     block[1][i] = t1 + t2;
  292.     block[2][i] = t1 - t2;
  293.     block[3][i] = t0 - t3;
  294.   }
  295. }
  297. //following functions perform 8 additions, 8 assignments. Should be a bit faster
  298. void hadamard2x2(int (*block)[16], int tblock[4])
  299. {
  300.   static int p0,p1,p2,p3;
  302.   p0 = block[0][0] + block[0][4];
  303.   p1 = block[0][0] - block[0][4];
  304.   p2 = block[4][0] + block[4][4];
  305.   p3 = block[4][0] - block[4][4];
  306.  
  307.   tblock[0] = (p0 + p2);
  308.   tblock[1] = (p1 + p3);
  309.   tblock[2] = (p0 - p2);
  310.   tblock[3] = (p1 - p3);
  311. }
  313. void ihadamard2x2(int tblock[4], int block[4])
  314. {
  315.   static int t0,t1,t2,t3;
  317.   t0 = tblock[0] + tblock[1];
  318.   t1 = tblock[0] - tblock[1];
  319.   t2 = tblock[2] + tblock[3];
  320.   t3 = tblock[2] - tblock[3];
  322.   block[0] = (t0 + t2);
  323.   block[1] = (t1 + t3);
  324.   block[2] = (t0 - t2);
  325.   block[3] = (t1 - t3);
  326. }
  328. /*
  329. void hadamard2x2(int (*block)[16], int tblock[4])
  330. {
  331.   //12 additions, 4 assignments
  332.     tblock[0] = (block[0][0] + block[0][4] + block[4][0] + block[4][4]);
  333.     tblock[1] = (block[0][0] - block[0][4] + block[4][0] - block[4][4]);
  334.     tblock[2] = (block[0][0] + block[0][4] - block[4][0] - block[4][4]);
  335.     tblock[3] = (block[0][0] - block[0][4] - block[4][0] + block[4][4]);
  336. }
  338. void ihadamard2x2(int tblock[4], int block[4])
  339. {
  340.     block[0] = (tblock[0] + tblock[1] + tblock[2] + tblock[3]);
  341.     block[1] = (tblock[0] - tblock[1] + tblock[2] - tblock[3]);
  342.     block[2] = (tblock[0] + tblock[1] - tblock[2] - tblock[3]);
  343.     block[3] = (tblock[0] - tblock[1] - tblock[2] + tblock[3]);
  344. }
  346. */
  349. void forward8x8(int (*block)[16], int (*tblock)[16], int pos_y, int pos_x)
  350. {
  351.   int i, ii;  
  352.   int *pTmp = tmp, *pblock;
  353.   static int a0, a1, a2, a3;
  354.   static int p0, p1, p2, p3, p4, p5 ,p6, p7;
  355.   static int b0, b1, b2, b3, b4, b5, b6, b7;
  357.   // Horizontal
  358.   for (i=pos_y; i < pos_y + BLOCK_SIZE_8x8; i++)
  359.   {
  360.     pblock = &block[i][pos_x];
  361.     p0 = *(pblock++);
  362.     p1 = *(pblock++);
  363.     p2 = *(pblock++);
  364.     p3 = *(pblock++);
  365.     p4 = *(pblock++);
  366.     p5 = *(pblock++);
  367.     p6 = *(pblock++);
  368.     p7 = *(pblock  );
  370.     a0 = p0 + p7;
  371.     a1 = p1 + p6;
  372.     a2 = p2 + p5;
  373.     a3 = p3 + p4;
  375.     b0 = a0 + a3;
  376.     b1 = a1 + a2;
  377.     b2 = a0 - a3;
  378.     b3 = a1 - a2;
  380.     a0 = p0 - p7;
  381.     a1 = p1 - p6;
  382.     a2 = p2 - p5;
  383.     a3 = p3 - p4;
  385.     b4 = a1 + a2 + ((a0 >> 1) + a0);
  386.     b5 = a0 - a3 - ((a2 >> 1) + a2);
  387.     b6 = a0 + a3 - ((a1 >> 1) + a1);
  388.     b7 = a1 - a2 + ((a3 >> 1) + a3);
  390.     *(pTmp++) =  b0 + b1;
  391.     *(pTmp++) =  b4 + (b7 >> 2);
  392.     *(pTmp++) =  b2 + (b3 >> 1);
  393.     *(pTmp++) =  b5 + (b6 >> 2);
  394.     *(pTmp++) =  b0 - b1;
  395.     *(pTmp++) =  b6 - (b5 >> 2);
  396.     *(pTmp++) = (b2 >> 1) - b3;                 
  397.     *(pTmp++) = (b4 >> 2) - b7;
  398.   }
  400.   // Vertical 
  401.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  402.   {
  403.     pTmp = tmp + i;
  404.     p0 = *pTmp;
  405.     p1 = *(pTmp += BLOCK_SIZE_8x8);
  406.     p2 = *(pTmp += BLOCK_SIZE_8x8);
  407.     p3 = *(pTmp += BLOCK_SIZE_8x8);
  408.     p4 = *(pTmp += BLOCK_SIZE_8x8);
  409.     p5 = *(pTmp += BLOCK_SIZE_8x8);
  410.     p6 = *(pTmp += BLOCK_SIZE_8x8);
  411.     p7 = *(pTmp += BLOCK_SIZE_8x8);
  413.     a0 = p0 + p7;
  414.     a1 = p1 + p6;
  415.     a2 = p2 + p5;
  416.     a3 = p3 + p4;
  418.     b0 = a0 + a3;
  419.     b1 = a1 + a2;
  420.     b2 = a0 - a3;
  421.     b3 = a1 - a2;
  423.     a0 = p0 - p7;
  424.     a1 = p1 - p6;
  425.     a2 = p2 - p5;
  426.     a3 = p3 - p4;
  428.     b4 = a1 + a2 + ((a0 >> 1) + a0);
  429.     b5 = a0 - a3 - ((a2 >> 1) + a2);
  430.     b6 = a0 + a3 - ((a1 >> 1) + a1);
  431.     b7 = a1 - a2 + ((a3 >> 1) + a3);
  433.     ii = pos_x + i;
  434.     tblock[pos_y    ][ii] =  b0 + b1;
  435.     tblock[pos_y + 1][ii] =  b4 + (b7 >> 2);
  436.     tblock[pos_y + 2][ii] =  b2 + (b3 >> 1);
  437.     tblock[pos_y + 3][ii] =  b5 + (b6 >> 2);
  438.     tblock[pos_y + 4][ii] =  b0 - b1;
  439.     tblock[pos_y + 5][ii] =  b6 - (b5 >> 2);
  440.     tblock[pos_y + 6][ii] = (b2 >> 1) - b3;
  441.     tblock[pos_y + 7][ii] = (b4 >> 2) - b7;
  442.   }
  443. }
  445. void inverse8x8(int (*tblock)[16], int (*block)[16], int pos_y, int pos_x)
  446. {
  447.   int i, ii;
  448.   int *pTmp = tmp, *pblock;
  449.   static int a0, a1, a2, a3;
  450.   static int p0, p1, p2, p3, p4, p5 ,p6, p7;  
  451.   static int b0, b1, b2, b3, b4, b5, b6, b7;
  453.   // Horizontal  
  454.   for (i=pos_y; i < pos_y + BLOCK_SIZE_8x8; i++)
  455.   {
  456.     pblock = &tblock[i][pos_x];
  457.     p0 = *(pblock++);
  458.     p1 = *(pblock++);
  459.     p2 = *(pblock++);
  460.     p3 = *(pblock++);
  461.     p4 = *(pblock++);
  462.     p5 = *(pblock++);
  463.     p6 = *(pblock++);
  464.     p7 = *(pblock  );
  466.     a0 = p0 + p4;
  467.     a1 = p0 - p4;
  468.     a2 = p6 - (p2 >> 1);
  469.     a3 = p2 + (p6 >> 1);
  471.     b0 =  a0 + a3;
  472.     b2 =  a1 - a2;
  473.     b4 =  a1 + a2;
  474.     b6 =  a0 - a3;
  476.     a0 = -p3 + p5 - p7 - (p7 >> 1);    
  477.     a1 =  p1 + p7 - p3 - (p3 >> 1);    
  478.     a2 = -p1 + p7 + p5 + (p5 >> 1);    
  479.     a3 =  p3 + p5 + p1 + (p1 >> 1);
  481.     
  482.     b1 =  a0 + (a3>>2);    
  483.     b3 =  a1 + (a2>>2);    
  484.     b5 =  a2 - (a1>>2);
  485.     b7 =  a3 - (a0>>2);                
  487.     *(pTmp++) = b0 + b7;
  488.     *(pTmp++) = b2 - b5;
  489.     *(pTmp++) = b4 + b3;
  490.     *(pTmp++) = b6 + b1;
  491.     *(pTmp++) = b6 - b1;
  492.     *(pTmp++) = b4 - b3;
  493.     *(pTmp++) = b2 + b5;
  494.     *(pTmp++) = b0 - b7;
  495.   }
  497.   //  Vertical 
  498.   for (i=0; i < BLOCK_SIZE_8x8; i++)
  499.   {
  500.     pTmp = tmp + i;
  501.     p0 = *pTmp;
  502.     p1 = *(pTmp += BLOCK_SIZE_8x8);
  503.     p2 = *(pTmp += BLOCK_SIZE_8x8);
  504.     p3 = *(pTmp += BLOCK_SIZE_8x8);
  505.     p4 = *(pTmp += BLOCK_SIZE_8x8);
  506.     p5 = *(pTmp += BLOCK_SIZE_8x8);
  507.     p6 = *(pTmp += BLOCK_SIZE_8x8);
  508.     p7 = *(pTmp += BLOCK_SIZE_8x8);
  510.     a0 =  p0 + p4;
  511.     a1 =  p0 - p4;
  512.     a2 =  p6 - (p2>>1);
  513.     a3 =  p2 + (p6>>1);
  515.     b0 = a0 + a3;
  516.     b2 = a1 - a2;
  517.     b4 = a1 + a2;
  518.     b6 = a0 - a3;
  520.     a0 = -p3 + p5 - p7 - (p7 >> 1);
  521.     a1 =  p1 + p7 - p3 - (p3 >> 1);
  522.     a2 = -p1 + p7 + p5 + (p5 >> 1);
  523.     a3 =  p3 + p5 + p1 + (p1 >> 1);
  526.     b1 =  a0 + (a3 >> 2);
  527.     b7 =  a3 - (a0 >> 2);
  528.     b3 =  a1 + (a2 >> 2);
  529.     b5 =  a2 - (a1 >> 2);
  531.     ii = i + pos_x;
  532.     block[pos_y    ][ii] = b0 + b7;
  533.     block[pos_y + 1][ii] = b2 - b5;
  534.     block[pos_y + 2][ii] = b4 + b3;
  535.     block[pos_y + 3][ii] = b6 + b1;
  536.     block[pos_y + 4][ii] = b6 - b1;
  537.     block[pos_y + 5][ii] = b4 - b3;
  538.     block[pos_y + 6][ii] = b2 + b5;
  539.     block[pos_y + 7][ii] = b0 - b7;
  540.   }
  541. }