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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
Mot_est.cpp
资源名称：263.rar　[点击查看]
上传用户：szklck
上传日期：2007-01-22
资源大小：925k
文件大小：12k
源码类别：

图形图像处理

开发平台：

Visual C++

Mot_est.cpp：源码内容
  1. #include"stdafx.h"
  2. #include"Global.h"
  4. /**********************************************************************
  5.  *
  6.  * Name:        MotionEstimation
  7.  * Description: Estimate all motionvectors for one MB
  8.  *
  9.  * Input:        pointers to current an previous image,
  10.  *        pointers to current slice and current MB
  11.  * Returns:
  12.  * Side effects: motion vector imformation in MB changed
  13.  *   
  14.  ***********************************************************************/
  17. void MotionEstimation(unsigned char *curr, unsigned char *prev, int x_curr,
  18.               int y_curr, int xoff, int yoff, int seek_dist, 
  19.               MotionVector *MV[6][MBR+1][MBC+2], int *SAD_0)
  21. {
  23.   int Min_FRAME[5];
  24.   MotionVector MV_FRAME[5];
  25.   unsigned char *act_block,*aa,*ii;
  26.   unsigned char *search_area, *adv_search_area = NULL, *zero_area = NULL;
  27.   int sxy,i,k,j,l;
  28.   int ihigh,ilow,jhigh,jlow,h_length,v_length;
  29.   int adv_ihigh,adv_ilow,adv_jhigh,adv_jlow,adv_h_length,adv_v_length;
  30.   int xmax,ymax,block,sad,lx;
  31.   int adv_x_curr, adv_y_curr,xvec,yvec;
  33.   xmax = pels;
  34.   ymax = lines;
  35.   sxy = seek_dist;
  36.   if (!long_vectors) {//以0矢量为中心的搜索范围
  37.     sxy = mmin(15, sxy);  
  38.   }
  39.   else {
  40.     /* Maximum extended search range centered around _predictor_ */
  41.     sxy = mmin(15 - (2*DEF_8X8_WIN+1), sxy);
  42.     xoff = mmin(16,mmax(-16,xoff));
  43.     yoff = mmin(16,mmax(-16,yoff));
  44.   }
  45.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  47.   ilow = x_curr + xoff - sxy;
  48.   ihigh = x_curr + xoff + sxy;
  50.   jlow = y_curr + yoff - sxy;
  51.   jhigh = y_curr + yoff + sxy;
  53.   if (!mv_outside_frame) {
  54.     if (ilow<0) ilow = 0;
  55.     if (ihigh>xmax-16) ihigh = xmax-16;
  56.     if (jlow<0) jlow = 0;
  57.     if (jhigh>ymax-16) jhigh = ymax-16;
  58.   }
  60.   h_length = ihigh - ilow + 16;
  61.   v_length = jhigh - jlow + 16;
  62.   act_block = LoadArea(curr, x_curr, y_curr, 16, 16, pels);  //装入当前搜索块
  63.   search_area = LoadArea(prev, ilow, jlow, h_length, v_length, lx);  //装入搜索范围块
  65.   for (k = 0; k < 5; k++) {
  66.     Min_FRAME[k] = INT_MAX;
  67.     MV_FRAME[k].x = 0;
  68.     MV_FRAME[k].y = 0;
  69.     MV_FRAME[k].x_half = 0;
  70.     MV_FRAME[k].y_half = 0;
  71.   }
  73.   /* 0运动矢量搜索 */
  74.   if (x_curr-ilow         < 0        || y_curr-jlow         < 0        ||
  75.       x_curr-ilow+MB_SIZE > h_length || y_curr-jlow+MB_SIZE > v_length) {
  76.     /* 0运动矢量位置不在search_area内 */
  77.     zero_area = LoadArea(prev, x_curr, y_curr, 16, 16, lx);  //装入0运动矢量块
  78.     *SAD_0 = SAD_Macroblock(zero_area, act_block, 16, Min_FRAME[0]) -
  79.        PREF_NULL_VEC;
  80.     free(zero_area);
  81.   }
  82.   else {
  83.     /* 0运动矢量位置在search_area内 */
  84.     ii = search_area + (x_curr-ilow) + (y_curr-jlow)*h_length;
  85.     *SAD_0 = SAD_Macroblock(ii, act_block, h_length, Min_FRAME[0]) -
  86.        PREF_NULL_VEC;
  87.   }
  89.   if (xoff == 0 && yoff == 0) {
  90.     Min_FRAME[0] = *SAD_0;
  91.     MV_FRAME[0].x = 0;
  92.     MV_FRAME[0].y = 0;
  93.   }
  94.   else {
  95.     ii = search_area + (x_curr+xoff-ilow) + (y_curr+yoff-jlow)*h_length;
  96.     Min_FRAME[0] = SAD_Macroblock(ii, act_block, h_length, Min_FRAME[0]);
  97.     MV_FRAME[0].x = xoff;
  98.     MV_FRAME[0].y = yoff;
  99.   }
  100.  
  101.   /* 螺旋搜索 */
  102.   for (l = 1; l <= sxy; l++) {
  103.     i = x_curr + xoff - l;
  104.     j = y_curr + yoff - l;
  105.     for (k = 0; k < 8*l; k++) {
  106.       if (i>=ilow && i<=ihigh && j>=jlow && j<=jhigh) {
  108.         /* 16x16块的整象素MV */
  109.         ii = search_area + (i-ilow) + (j-jlow)*h_length;
  110.         sad = SAD_Macroblock(ii, act_block, h_length, Min_FRAME[0]);
  111.         if (sad < Min_FRAME[0]) {
  112.           MV_FRAME[0].x = i - x_curr;
  113.           MV_FRAME[0].y = j - y_curr;
  114.           Min_FRAME[0] = sad;
  115.         }
  117.       }
  118.       if      (k<2*l) i++;
  119.       else if (k<4*l) j++;
  120.       else if (k<6*l) i--;
  121.       else            j--;
  122.     }      
  123.   }
  126.   if (advanced) {
  128.     /* 8x8块搜索以16x16矢量为中心，仍然采用全搜索方法。*/
  130.     xvec = MV_FRAME[0].x;
  131.     yvec = MV_FRAME[0].y;
  132.     
  133.     if (!long_vectors) {
  134.       if (xvec > 15 - DEF_8X8_WIN) { xvec =  15 - DEF_8X8_WIN ;}
  135.       if (yvec > 15 - DEF_8X8_WIN) { yvec =  15 - DEF_8X8_WIN ;}
  137.       if (xvec < -15 + DEF_8X8_WIN) { xvec =  -15 + DEF_8X8_WIN ;}
  138.       if (yvec < -15 + DEF_8X8_WIN) { yvec =  -15 + DEF_8X8_WIN ;}
  139.     }
  141.     adv_x_curr = x_curr  + xvec;
  142.     adv_y_curr = y_curr  + yvec;
  144.     sxy = DEF_8X8_WIN;
  146.     adv_ilow = adv_x_curr - sxy;
  147.     adv_ihigh = adv_x_curr + sxy;
  149.     adv_jlow = adv_y_curr - sxy;
  150.     adv_jhigh = adv_y_curr + sxy;
  152.     adv_h_length = adv_ihigh - adv_ilow + 16;
  153.     adv_v_length = adv_jhigh - adv_jlow + 16;
  155.     adv_search_area = LoadArea(prev, adv_ilow, adv_jlow, 
  156.                adv_h_length, adv_v_length, lx);
  158.     for (block = 0; block < 4; block++) {
  159.       ii = adv_search_area + (adv_x_curr-adv_ilow) + ((block&1)<<3) + 
  160.         (adv_y_curr-adv_jlow + ((block&2)<<2) )*adv_h_length;
  161.       aa = act_block + ((block&1)<<3) + ((block&2)<<2)*16;
  162.       Min_FRAME[block+1] = SAD_Block(ii,aa,adv_h_length,Min_FRAME[block+1]);
  163.       MV_FRAME[block+1].x = MV_FRAME[0].x;
  164.       MV_FRAME[block+1].y = MV_FRAME[0].y;
  165.     }
  167.     /* 螺旋搜索 */
  168.     for (l = 1; l <= sxy; l++) {
  169.       i = adv_x_curr - l;
  170.       j = adv_y_curr - l;
  171.       for (k = 0; k < 8*l; k++) {
  172.         if (i>=adv_ilow && i<=adv_ihigh && j>=adv_jlow && j<=adv_jhigh) {
  173.           
  174.           /* 8x8块的整象素MVs */
  175.           for (block = 0; block < 4; block++) {
  176.             ii = adv_search_area + (i-adv_ilow) + ((block&1)<<3) + 
  177.               (j-adv_jlow + ((block&2)<<2) )*adv_h_length;
  178.             aa = act_block + ((block&1)<<3) + ((block&2)<<2)*16;
  179.             sad = SAD_Block(ii, aa, adv_h_length, Min_FRAME[block+1]);
  180.             if (sad < Min_FRAME[block+1]) {
  181.               MV_FRAME[block+1].x = i - x_curr;
  182.               MV_FRAME[block+1].y = j - y_curr;
  183.               Min_FRAME[block+1] = sad;
  184.             }
  185.           }
  186.           
  187.         }
  188.         if      (k<2*l) i++;
  189.         else if (k<4*l) j++;
  190.         else if (k<6*l) i--;
  191.         else            j--;
  192.       }      
  193.     }
  195.   }
  197.   i = x_curr/MB_SIZE+1;
  198.   j = y_curr/MB_SIZE+1;
  200.   if (!advanced) {
  201.     MV[0][j][i]->x = MV_FRAME[0].x;
  202.     MV[0][j][i]->y = MV_FRAME[0].y;
  203.     MV[0][j][i]->min_error = Min_FRAME[0];
  204.   }
  205.   else {
  206.     for (k = 0; k < 5; k++) {
  207.       MV[k][j][i]->x = MV_FRAME[k].x;
  208.       MV[k][j][i]->y = MV_FRAME[k].y;
  209.       MV[k][j][i]->min_error = Min_FRAME[k];
  210.     }
  211.   }
  213.   free(act_block);
  214.   free(search_area);
  215.   if (advanced)
  216.     free(adv_search_area);
  217.   return;
  218. }
  220. /**********************************************************************
  221.  *
  222.  * Name:        LoadArea
  223.  * Description:    fills array with a square of image-data
  224.  *
  225.  * Input:        pointer to image and position, x and y size
  226.  * Returns:       pointer to area
  227.  * Side effects:  memory allocated to array
  228.  *
  229.  * Date: 940203 Author: PGB
  230.  *                      Mod: KOL
  231.  *
  232.  ***********************************************************************/
  235. unsigned char *LoadArea(unsigned char *im, int x, int y, 
  236.         int x_size, int y_size, int lx)
  237. {
  238.   unsigned char *res = (unsigned char *)malloc(sizeof(char)*x_size*y_size);
  239.   unsigned char *in;
  240.   unsigned char *out;
  241.   int i = x_size;
  242.   int j = y_size;
  244.   in = im + (y*lx) + x;
  245.   out = res;
  247.   while (j--) {
  248.     while (i--)
  249.       *out++ = *in++;
  250.     i = x_size;
  251.     in += lx - x_size;
  252.   };
  253.   return res;
  254. }
  256. /**********************************************************************
  257.  *
  258.  * Name:        SAD_Macroblock
  259.  * Description:    fast way to find the SAD of one vector
  260.  *
  261.  * Input:         pointers to search_area and current block,
  262.  *                      Min_F1/F2/FR
  263.  * Returns:        sad_f1/f2
  264.  * Side effects:
  265.  *
  266.  * Date: 940203        Author: PGB
  267.  *                      Mod:    KOL
  268.  *
  269.  ***********************************************************************/
  272. int SAD_Macroblock(unsigned char *ii, unsigned char *act_block,
  273.            int h_length, int Min_FRAME)
  274. {
  275.   int i;
  276.   int sad = 0;
  277.   unsigned char *kk;
  279.   kk = act_block;
  280.   i = 16;
  281.   while (i--) {
  282.     sad += (abs(*ii     - *kk     ) +abs(*(ii+1 ) - *(kk+1) )
  283.             +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) )
  284.             +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) )
  285.             +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) )
  286.             +abs(*(ii+8) - *(kk+8) ) +abs(*(ii+9 ) - *(kk+9) )
  287.             +abs(*(ii+10)- *(kk+10)) +abs(*(ii+11) - *(kk+11))
  288.             +abs(*(ii+12)- *(kk+12)) +abs(*(ii+13) - *(kk+13))
  289.             +abs(*(ii+14)- *(kk+14)) +abs(*(ii+15) - *(kk+15)) );
  291.     ii += h_length;
  292.     kk += 16;
  293.     if (sad > Min_FRAME)
  294.       return INT_MAX;
  295.   } 
  296.   return sad;
  297. }
  299. int SAD_Block(unsigned char *ii, unsigned char *act_block,
  300.               int h_length, int min_sofar)
  301. {
  302.   int i;
  303.   int sad = 0;
  304.   unsigned char *kk;
  306.   kk = act_block;
  307.   i = 8;
  308.   while (i--) {
  309.     sad += (abs(*ii     - *kk     ) +abs(*(ii+1 ) - *(kk+1) )
  310.             +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) )
  311.             +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) )
  312.             +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) ));
  314.     ii += h_length;
  315.     kk += 16;
  316.     if (sad > min_sofar)
  317.       return INT_MAX;
  318.   } 
  319.   return sad;
  320. }
  322. int SAD_MB_Bidir(unsigned char *ii, unsigned char *aa, unsigned char *bb, 
  323.          int width, int min_sofar)
  324. {
  325.   int i, sad = 0;
  326.   unsigned char *ll, *kk;
  327.   kk = aa;
  328.   ll = bb;
  329.   i = 16;
  330.   while (i--) {
  331.     sad += (abs(*ii     - ((*kk    + *ll    )>>1)) +
  332.             abs(*(ii+1) - ((*(kk+1)+ *(ll+1))>>1)) +
  333.             abs(*(ii+2) - ((*(kk+2)+ *(ll+2))>>1)) +
  334.             abs(*(ii+3) - ((*(kk+3)+ *(ll+3))>>1)) +
  335.             abs(*(ii+4) - ((*(kk+4)+ *(ll+4))>>1)) +
  336.             abs(*(ii+5) - ((*(kk+5)+ *(ll+5))>>1)) +
  337.             abs(*(ii+6) - ((*(kk+6)+ *(ll+6))>>1)) +
  338.             abs(*(ii+7) - ((*(kk+7)+ *(ll+7))>>1)) +
  339.             abs(*(ii+8) - ((*(kk+8)+ *(ll+8))>>1)) +
  340.             abs(*(ii+9) - ((*(kk+9)+ *(ll+9))>>1)) +
  341.             abs(*(ii+10) - ((*(kk+10)+ *(ll+10))>>1)) +
  342.             abs(*(ii+11) - ((*(kk+11)+ *(ll+11))>>1)) +
  343.             abs(*(ii+12) - ((*(kk+12)+ *(ll+12))>>1)) +
  344.             abs(*(ii+13) - ((*(kk+13)+ *(ll+13))>>1)) +
  345.             abs(*(ii+14) - ((*(kk+14)+ *(ll+14))>>1)) +
  346.             abs(*(ii+15) - ((*(kk+15)+ *(ll+15))>>1)));
  348.     ii += width;
  349.     kk += width;
  350.     ll += width;
  351.     if (sad > min_sofar)
  352.       return INT_MAX;
  353.   } 
  354.   return sad;
  355. }
  357. int SAD_MB_integer(int *ii, int *act_block, int h_length, int min_sofar)
  358. {
  359.   int i, sad = 0, *kk;
  361.   kk = act_block;
  362.   i = 16;
  363.   while (i--) {
  364.     sad += (abs(*ii     - *kk     ) +abs(*(ii+1 ) - *(kk+1) )
  365.             +abs(*(ii+2) - *(kk+2) ) +abs(*(ii+3 ) - *(kk+3) )
  366.             +abs(*(ii+4) - *(kk+4) ) +abs(*(ii+5 ) - *(kk+5) )
  367.             +abs(*(ii+6) - *(kk+6) ) +abs(*(ii+7 ) - *(kk+7) )
  368.             +abs(*(ii+8) - *(kk+8) ) +abs(*(ii+9 ) - *(kk+9) )
  369.             +abs(*(ii+10)- *(kk+10)) +abs(*(ii+11) - *(kk+11))
  370.             +abs(*(ii+12)- *(kk+12)) +abs(*(ii+13) - *(kk+13))
  371.             +abs(*(ii+14)- *(kk+14)) +abs(*(ii+15) - *(kk+15)) );
  373.     ii += h_length;
  374.     kk += 16;
  375.     if (sad > min_sofar)
  376.       return INT_MAX;
  377.   } 
  378.   return sad;
  379. }
  381. /**********************************************************************
  382.  *
  383.  * Name:        FindMB
  384.  * Description: Picks out one MB from picture
  385.  *
  386.  * Input:        position of MB to pick out,
  387.  *        pointer to frame data, empty 16x16 array
  388.  * Returns:
  389.  * Side effects: fills array with MB data
  390.  *
  391.  * Date: 930119 Author: Karl Olav Lillevold
  392.  *
  393.  ***********************************************************************/
  395. void FindMB(int x, int y, unsigned char *image, int MB[16][16])
  397. {
  398.   int n;
  399.   register int m;
  401.   for (n = 0; n < MB_SIZE; n++)
  402.     for (m = 0; m < MB_SIZE; m++)
  403.       MB[n][m] = *(image + x+m + (y+n)*pels);
  404. }