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

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

Audio

开发平台：

Visual C++

loopFilter.c：源码内容
  2. /*!
  3.  *************************************************************************************
  4.  * file loopFilter.c
  5.  *
  6.  * brief
  7.  *    Filter to reduce blocking artifacts on a macroblock level.
  8.  *    The filter strength is QP dependent.
  9.  *
  10.  * author
  11.  *    Contributors:
  12.  *    - Peter List       Peter.List@t-systems.de:  Original code                                 (13-Aug-2001)
  13.  *    - Jani Lainema     Jani.Lainema@nokia.com:   Some bug fixing, removal of recursiveness     (16-Aug-2001)
  14.  *    - Peter List       Peter.List@t-systems.de:  inplace filtering and various simplifications (10-Jan-2002)
  15.  *    - Anthony Joch     anthony@ubvideo.com:      Simplified switching between filters and
  16.  *                                                 non-recursive default filter.                 (08-Jul-2002)
  17.  *    - Cristina Gomila  cristina.gomila@thomson.net: Simplification of the chroma deblocking
  18.  *                                                    from JVT-E089                              (21-Nov-2002)
  19.  *    - Alexis Michael Tourapis atour@dolby.com:   Speed/Architecture improvements               (08-Feb-2007)
  20.  *************************************************************************************
  21.  */
  23. #include "global.h"
  24. #include "image.h"
  25. #include "mb_access.h"
  27. byte mixedModeEdgeFlag, fieldModeFilteringFlag;
  29. static int64  **list0_refPicIdArr, **list1_refPicIdArr;
  30. static short  ***list0_mv, ***list1_mv;
  31. static char   **list0_refIdxArr, **list1_refIdxArr;
  32. static Macroblock *MbP, *MbQ;
  33. static imgpel   *SrcPtrP, *SrcPtrQ;
  35. /*********************************************************************************************************/
  37. // NOTE: In principle, the alpha and beta tables are calculated with the formulas below
  38. //       Alpha( qp ) = 0.8 * (2^(qp/6)  -  1)
  39. //       Beta ( qp ) = 0.5 * qp  -  7
  41. // The tables actually used have been "hand optimized" though (by Anthony Joch). So, the
  42. // table values might be a little different to formula-generated values. Also, the first
  43. // few values of both tables is set to zero to force the filter off at low qp抯
  45. static const byte ALPHA_TABLE[52]  = {0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,4,4,5,6,  7,8,9,10,12,13,15,17,  20,22,25,28,32,36,40,45,  50,56,63,71,80,90,101,113,  127,144,162,182,203,226,255,255} ;
  46. static const byte  BETA_TABLE[52]  = {0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,2,2,2,3,  3,3,3, 4, 4, 4, 6, 6,   7, 7, 8, 8, 9, 9,10,10,  11,11,12,12,13,13, 14, 14,   15, 15, 16, 16, 17, 17, 18, 18} ;
  47. static const byte CLIP_TAB[52][5]  =
  48. {
  49.   { 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},
  50.   { 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},
  51.   { 0, 0, 0, 0, 0},{ 0, 0, 0, 1, 1},{ 0, 0, 0, 1, 1},{ 0, 0, 0, 1, 1},{ 0, 0, 0, 1, 1},{ 0, 0, 1, 1, 1},{ 0, 0, 1, 1, 1},{ 0, 1, 1, 1, 1},
  52.   { 0, 1, 1, 1, 1},{ 0, 1, 1, 1, 1},{ 0, 1, 1, 1, 1},{ 0, 1, 1, 2, 2},{ 0, 1, 1, 2, 2},{ 0, 1, 1, 2, 2},{ 0, 1, 1, 2, 2},{ 0, 1, 2, 3, 3},
  53.   { 0, 1, 2, 3, 3},{ 0, 2, 2, 3, 3},{ 0, 2, 2, 4, 4},{ 0, 2, 3, 4, 4},{ 0, 2, 3, 4, 4},{ 0, 3, 3, 5, 5},{ 0, 3, 4, 6, 6},{ 0, 3, 4, 6, 6},
  54.   { 0, 4, 5, 7, 7},{ 0, 4, 5, 8, 8},{ 0, 4, 6, 9, 9},{ 0, 5, 7,10,10},{ 0, 6, 8,11,11},{ 0, 6, 8,13,13},{ 0, 7,10,14,14},{ 0, 8,11,16,16},
  55.   { 0, 9,12,18,18},{ 0,10,13,20,20},{ 0,11,15,23,23},{ 0,13,17,25,25}
  56. } ;
  58. static const char chroma_edge[2][4][4] = //[dir][edge][yuv_format]
  59. { { {-4, 0, 0, 0},
  60.     {-4,-4,-4, 4},
  61.     {-4, 4, 4, 8},
  62.     {-4,-4,-4, 12}},
  64.   { {-4, 0,  0,  0},
  65.     {-4,-4,  4,  4},
  66.     {-4, 4,  8,  8},
  67.     {-4,-4, 12, 12}}};
  69. static const int pelnum_cr[2][4] =  {{0,8,16,16}, {0,8, 8,16}};  //[dir:0=vert, 1=hor.][yuv_format]
  71. void (*GetStrength)(byte Strength[16],ImageParameters *img,int MbQAddr,int dir,int edge, int mvlimit);
  72. void GetStrengthNormal(byte Strength[16],ImageParameters *img,int MbQAddr,int dir,int edge, int mvlimit);
  73. void GetStrengthMBAff(byte Strength[16],ImageParameters *img,int MbQAddr,int dir,int edge, int mvlimit);
  74. void (*EdgeLoopLuma)(ColorPlane pl, imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width);
  75. void EdgeLoopLumaNormal(ColorPlane pl, imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width);
  76. void EdgeLoopLumaMBAff(ColorPlane pl, imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width);
  77. void (*EdgeLoopChroma)(imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width, int uv);
  78. void EdgeLoopChromaNormal(imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width, int uv);
  79. void EdgeLoopChromaMBAff(imgpel** Img, byte Strength[16],ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width, int uv);
  81. void DeblockMb(ImageParameters *img, imgpel **imgY, imgpel ***imgUV, int MbQAddr);
  84. /*!
  85.  *****************************************************************************************
  86.  * brief
  87.  *    Filter all macroblocks in order of increasing macroblock address.
  88.  *****************************************************************************************
  89.  */
  90. void DeblockFrame(ImageParameters *img, imgpel **imgY, imgpel ***imgUV)
  91. {
  92.   unsigned i;
  94.   if (img->MbaffFrameFlag == 1) 
  95.   {
  96.     GetStrength    = GetStrengthMBAff;
  97.     EdgeLoopLuma   = EdgeLoopLumaMBAff;
  98.     EdgeLoopChroma = EdgeLoopChromaMBAff;
  99.   }
  100.   else
  101.   {
  102.     GetStrength    = GetStrengthNormal;
  103.     EdgeLoopLuma   = EdgeLoopLumaNormal;
  104.     EdgeLoopChroma = EdgeLoopChromaNormal;
  105.   }
  107.   for (i=0; i < img->PicSizeInMbs; i++)
  108.   {
  109.     if (img->mb_data[i].mb_type==IPCM)
  110.     {
  111.       img->mb_data[i].qp = 0;
  112.       img->mb_data[i].qpc[0] = 0;
  113.       img->mb_data[i].qpc[1] = 0;
  114.     }
  115.   }
  117.   for (i=0; i < img->PicSizeInMbs; i++)
  118.   {
  119.     DeblockMb( img, imgY, imgUV, i ) ;
  120.   }
  121. }
  123. /*!
  124.  *****************************************************************************************
  125.  * brief
  126.  *    Deblocking filter for one macroblock.
  127.  *****************************************************************************************
  128.  */
  130. void DeblockMb(ImageParameters *img, imgpel **imgY, imgpel ***imgUV, int MbQAddr)
  131. {
  132.   int           EdgeCondition;
  133.   int           dir, edge;
  134.   byte          Strength[16];
  135.   int           mb_x, mb_y;
  137.   int           filterNon8x8LumaEdgesFlag[4] = {1,1,1,1};
  138.   int           filterLeftMbEdgeFlag;
  139.   int           filterTopMbEdgeFlag;
  140.   int           fieldModeMbFlag;
  141.   int           mvlimit = 4;
  142.   int           i, StrengthSum;
  143.   Macroblock    *MbQ;
  145.   int           edge_cr;
  146.   int           *mb_size = img->mb_size[IS_LUMA];
  148.   img->DeblockCall = 1;
  149.   get_mb_pos (MbQAddr, mb_size, &mb_x, &mb_y);
  151.   filterLeftMbEdgeFlag = (mb_x != 0);
  152.   filterTopMbEdgeFlag  = (mb_y != 0);
  154.   MbQ = &(img->mb_data[MbQAddr]) ; // current Mb
  156.   if (MbQ->mb_type == I8MB)
  157.     assert(MbQ->luma_transform_size_8x8_flag);
  159.   filterNon8x8LumaEdgesFlag[1] =
  160.   filterNon8x8LumaEdgesFlag[3] = !(MbQ->luma_transform_size_8x8_flag);
  162.   if (img->MbaffFrameFlag && mb_y == MB_BLOCK_SIZE && MbQ->mb_field)
  163.     filterTopMbEdgeFlag = 0;
  165.   fieldModeMbFlag = (img->structure!=FRAME) || (img->MbaffFrameFlag && MbQ->mb_field);
  166.   if (fieldModeMbFlag)
  167.     mvlimit = 2;
  169.   // return, if filter is disabled
  170.   if (MbQ->DFDisableIdc==1) 
  171.   {
  172.     img->DeblockCall = 0;
  173.     return;
  174.   }
  176.   if (MbQ->DFDisableIdc==2)
  177.   {
  178.     // don't filter at slice boundaries
  179.     filterLeftMbEdgeFlag = MbQ->mbAvailA;
  180.     // if this the bottom of a frame macroblock pair then always filter the top edge
  181.     filterTopMbEdgeFlag  = (img->MbaffFrameFlag && !MbQ->mb_field && (MbQAddr & 0x01)) ? 1 : MbQ->mbAvailB;
  182.   }
  183.   img->current_mb_nr = MbQAddr;
  184.   CheckAvailabilityOfNeighbors(&img->mb_data[MbQAddr]);
  186.   for( dir = 0 ; dir < 2 ; dir++ )                                                      // filter first vertical edges, followed by horizontal 
  187.   {
  188.     EdgeCondition = (dir && filterTopMbEdgeFlag) || (!dir && filterLeftMbEdgeFlag); // can not filter beyond picture boundaries
  189.     for( edge=0; edge<4 ; edge++ )                                            // first 4 vertical strips of 16 pel
  190.     {                                                                               // then  4 horizontal
  191.       if( edge || EdgeCondition )
  192.       {
  193.         edge_cr = chroma_edge[dir][edge][img->yuv_format];
  195.         GetStrength(Strength, img, MbQAddr, dir, edge << 2, mvlimit); // Strength for 4 blks in 1 stripe
  196.         StrengthSum = Strength[0];
  197.         for (i = 1; i < MB_BLOCK_SIZE && StrengthSum == 0 ; i++)
  198.         {
  199.           StrengthSum += Strength[i];
  200.         }       
  201.         
  202.         if( StrengthSum )                      // only if one of the 16 Strength bytes is != 0
  203.         {
  204.           if (filterNon8x8LumaEdgesFlag[edge])
  205.           {
  206.             EdgeLoopLuma( PLANE_Y, imgY, Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, edge << 2, img->width) ;
  207.             if (img->P444_joined)
  208.             {
  209.               EdgeLoopLuma(PLANE_U, imgUV[0], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, edge << 2, img->width);
  210.               EdgeLoopLuma(PLANE_V, imgUV[1], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, edge << 2, img->width);
  211.             }
  212.           }
  213.           if(img->yuv_format==YUV420 || img->yuv_format==YUV422 )
  214.           {
  215.             if( (imgUV != NULL) && (edge_cr >= 0))
  216.             {
  217.               EdgeLoopChroma( imgUV[0], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, edge_cr, img->width_cr, 0);
  218.               EdgeLoopChroma( imgUV[1], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, edge_cr, img->width_cr, 1);
  219.             }
  220.           }
  221.         }
  223.         if (dir && !edge && !MbQ->mb_field && mixedModeEdgeFlag) 
  224.         {
  225.           // this is the extra horizontal edge between a frame macroblock pair and a field above it
  226.           img->DeblockCall = 2;
  227.           GetStrength(Strength, img, MbQAddr, dir, MB_BLOCK_SIZE, mvlimit); // Strength for 4 blks in 1 stripe
  228.           //if( *((int*)Strength) )                      // only if one of the 4 Strength bytes is != 0
  229.           {
  230.             if (filterNon8x8LumaEdgesFlag[edge])
  231.             {
  232.               EdgeLoopLuma( PLANE_Y, imgY, Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, 16, img->width) ;
  233.               if (img->P444_joined)
  234.               {
  235.                 EdgeLoopLuma(PLANE_U, imgUV[0], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, 16, img->width) ;
  236.                 EdgeLoopLuma(PLANE_V, imgUV[1], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, 16, img->width) ;
  237.               }
  238.             }
  239.             if( img->yuv_format == YUV420 || img->yuv_format==YUV422 )
  240.             {
  241.               if( (imgUV != NULL) && (edge_cr >= 0))
  242.               {
  243.                 EdgeLoopChroma( imgUV[0], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, MB_BLOCK_SIZE, img->width_cr, 0) ;
  244.                 EdgeLoopChroma( imgUV[1], Strength, img, MbQAddr, MbQ->DFAlphaC0Offset, MbQ->DFBetaOffset, dir, MB_BLOCK_SIZE, img->width_cr, 1) ;
  245.               }
  246.             }
  247.           }
  248.           img->DeblockCall = 1;
  249.         }
  250.       }
  251.     }//end edge
  252.   }//end loop dir
  254.   img->DeblockCall = 0;
  255. }
  257.   /*!
  258.  *********************************************************************************************
  259.  * brief
  260.  *    returns a buffer of 16 Strength values for one stripe in a mb (for different Frame or Field types)
  261.  *********************************************************************************************
  262.  */
  264. #define ANY_INTRA (MbP->mb_type==I4MB||MbP->mb_type==I8MB||MbP->mb_type==I16MB||MbP->mb_type==IPCM||MbQ->mb_type==I4MB||MbQ->mb_type==I8MB||MbQ->mb_type==I16MB||MbQ->mb_type==IPCM)
  266. void GetStrengthNormal(byte Strength[MB_BLOCK_SIZE],ImageParameters *img,int MbQAddr,int dir,int edge, int mvlimit)
  267. {
  268.   static int64    ref_p0,ref_p1,ref_q0,ref_q1;
  269.   static int      blkP, blkQ, idx;
  270.   static int      blk_x, blk_x2, blk_y, blk_y2 ;
  271.   static int      xQ, yQ;
  272.   static int      mb_x, mb_y;
  273.   static PixelPos pixP, pixMB;
  274.   static byte     StrValue;
  275.   int             *mb_size = img->mb_size[IS_LUMA];
  277.   if ((img->type==SP_SLICE)||(img->type==SI_SLICE))
  278.   {
  279.     // Set strength to either 3 or 4 regardless of pixel position
  280.     StrValue = (edge == 0 && (((img->structure==FRAME)) || ((img->structure != FRAME) && !dir))) ? 4 : 3;
  281.     memset(&Strength[0], (byte) StrValue, MB_BLOCK_SIZE * sizeof(byte));
  282.   }
  283.   else
  284.   {    
  285.     xQ = dir ? 0 : edge - 1;
  286.     yQ = dir ? (edge < 16 ? edge - 1: 0) : 0;
  288.     MbQ = &(img->mb_data[MbQAddr]);
  289.     getNeighbour(MbQ, xQ, yQ, mb_size, &pixMB);
  290.     pixP = pixMB;
  291.     MbP = &(img->mb_data[pixP.mb_addr]);
  293.     if (!ANY_INTRA)
  294.     {
  295.       list0_refPicIdArr = enc_picture->motion.ref_pic_id[LIST_0];
  296.       list1_refPicIdArr = enc_picture->motion.ref_pic_id[LIST_1];
  297.       list0_mv = enc_picture->motion.mv[LIST_0];
  298.       list1_mv = enc_picture->motion.mv[LIST_1];
  299.       list0_refIdxArr = enc_picture->motion.ref_idx[LIST_0];
  300.       list1_refIdxArr = enc_picture->motion.ref_idx[LIST_1];
  301.  
  302.       get_mb_block_pos (MbQAddr, &mb_x, &mb_y);
  303.       mb_x <<= 2;
  304.       mb_y <<= 2;
  306.       yQ += dir;
  307.       xQ += (1 - dir);
  309.       for( idx = 0 ; idx < MB_BLOCK_SIZE ; idx += BLOCK_SIZE )
  310.       {
  311.         if (dir)
  312.         {
  313.           xQ = idx;
  314.           pixP.x = pixMB.x + idx;
  315.           pixP.pos_x = pixMB.pos_x + idx;
  316.         }
  317.         else
  318.         {
  319.           yQ = idx;
  320.           pixP.y = pixMB.y + idx;
  321.           pixP.pos_y = pixMB.pos_y + idx;
  322.         }
  324.         blkQ = ((yQ >> 2) << 2) + (xQ >> 2);
  325.         blkP = ((pixP.y >> 2) << 2) + (pixP.x >> 2);
  327.         if( ((MbQ->cbp_blk & ((int64)1 << blkQ )) != 0) || ((MbP->cbp_blk &  ((int64)1 << blkP)) != 0) )
  328.           StrValue = 2;
  329.         else
  330.         {
  331.           // if no coefs, but vector difference >= 1 set Strength=1
  332.           // if this is a mixed mode edge then one set of reference pictures will be frame and the
  333.           // other will be field          
  334.           blk_y  = mb_y + (blkQ >> 2);
  335.           blk_x  = mb_x + (blkQ  & 3);
  336.           blk_y2 = pixP.pos_y >> 2;
  337.           blk_x2 = pixP.pos_x >> 2;
  339.           ref_p0 = list0_refIdxArr[blk_y] [blk_x] <0 ? INT64_MIN : list0_refPicIdArr[blk_y] [blk_x];
  340.           ref_q0 = list0_refIdxArr[blk_y2][blk_x2]<0 ? INT64_MIN : list0_refPicIdArr[blk_y2][blk_x2];
  341.           ref_p1 = list1_refIdxArr[blk_y] [blk_x] <0 ? INT64_MIN : list1_refPicIdArr[blk_y] [blk_x];
  342.           ref_q1 = list1_refIdxArr[blk_y2][blk_x2]<0 ? INT64_MIN : list1_refPicIdArr[blk_y2][blk_x2];
  343.           if ( ((ref_p0==ref_q0) && (ref_p1==ref_q1)) || ((ref_p0==ref_q1) && (ref_p1==ref_q0)))
  344.           {
  345.             // L0 and L1 reference pictures of p0 are different; q0 as well
  346.             if (ref_p0 != ref_p1)
  347.             {
  348.               // compare MV for the same reference picture
  349.               if (ref_p0 == ref_q0)
  350.               {
  351.                 StrValue =  (byte) (
  352.                   (iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  353.                   (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  354.                   (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  355.                   (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit));                  
  356.               }
  357.               else
  358.               {
  359.                 StrValue =  (byte) (
  360.                   (iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  361.                   (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  362.                   (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  363.                   (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit));
  364.               }
  365.             }
  366.             else
  367.             { // L0 and L1 reference pictures of p0 are the same; q0 as well
  368.               StrValue = (byte) (
  369.                 ((iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  370.                 (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit ) |
  371.                 (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  372.                 (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit))
  373.                 &&
  374.                 ((iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  375.                 (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  376.                 (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  377.                 (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit)));
  378.             }
  379.           }
  380.           else
  381.           {
  382.             StrValue = 1;
  383.           }
  384.         }        
  385.         memset(&Strength[idx], (byte) StrValue, BLOCK_SIZE * sizeof(byte));
  386.       }
  387.     }
  388.     else
  389.     {
  390.       // Start with Strength=3. or Strength=4 for Mb-edge
  391.       StrValue = (edge == 0 && ((((img->structure==FRAME))) || ((img->structure != FRAME) && !dir))) ? 4 : 3;
  392.       memset(&Strength[0], (byte) StrValue, MB_BLOCK_SIZE * sizeof(byte));
  393.     }      
  394.   }
  395. }
  397. /*!
  398.  *********************************************************************************************
  399.  * brief
  400.  *    returns a buffer of 16 Strength values for one stripe in a mb (for MBAFF)
  401.  *********************************************************************************************
  402.  */
  403. void GetStrengthMBAff(byte Strength[16],ImageParameters *img,int MbQAddr,int dir,int edge, int mvlimit)
  404. {
  405.   int    blkP, blkQ, idx;
  406.   int    blk_x, blk_x2, blk_y, blk_y2 ;
  407.   int64    ref_p0,ref_p1,ref_q0,ref_q1;
  408.   int      xQ, yQ;
  409.   int      mb_x, mb_y;
  411.   PixelPos pixP;
  412.   int dir_m1 = (1 - dir);
  413.   int *mb_size = img->mb_size[IS_LUMA];
  415.   MbQ = &(img->mb_data[MbQAddr]);
  416.   list0_mv = enc_picture->motion.mv[LIST_0];
  417.   list1_mv = enc_picture->motion.mv[LIST_1];
  418.   list0_refIdxArr = enc_picture->motion.ref_idx[LIST_0];
  419.   list1_refIdxArr = enc_picture->motion.ref_idx[LIST_1];
  420.   list0_refPicIdArr = enc_picture->motion.ref_pic_id[LIST_0];
  421.   list1_refPicIdArr = enc_picture->motion.ref_pic_id[LIST_1];
  422.  
  423.   for( idx=0 ; idx<16 ; idx++ )
  424.   {
  425.     xQ = dir ? idx : edge;
  426.     yQ = dir ? (edge < MB_BLOCK_SIZE ? edge : 1) : idx;
  427.     getNeighbour(MbQ, xQ - dir_m1, yQ - dir, mb_size, &pixP);
  428.     blkQ = ((yQ >> 2) << 2) + (xQ >> 2);
  429.     blkP = ((pixP.y >> 2)<<2) + (pixP.x >> 2);
  431.     MbP = &(img->mb_data[pixP.mb_addr]);
  432.     mixedModeEdgeFlag = (byte) (MbQ->mb_field != MbP->mb_field);   
  434.     if ((img->type==SP_SLICE)||(img->type==SI_SLICE) )
  435.     {
  436.       Strength[idx] = (edge == 0 && (((!img->MbaffFrameFlag && (img->structure==FRAME)) ||
  437.       (img->MbaffFrameFlag && !MbP->mb_field && !MbQ->mb_field)) ||
  438.       ((img->MbaffFrameFlag || (img->structure != FRAME)) && !dir))) ? 4 : 3;
  439.     }
  440.     else
  441.     {
  442.       // Start with Strength=3. or Strength=4 for Mb-edge
  443.       Strength[idx] = (edge == 0 && (((!img->MbaffFrameFlag && (img->structure==FRAME)) ||
  444.         (img->MbaffFrameFlag && !MbP->mb_field && !MbQ->mb_field)) ||
  445.         ((img->MbaffFrameFlag || (img->structure!=FRAME)) && !dir))) ? 4 : 3;
  447.       if(  !(MbP->mb_type==I4MB || MbP->mb_type==I16MB || MbP->mb_type==I8MB || MbP->mb_type==IPCM)
  448.         && !(MbQ->mb_type==I4MB || MbQ->mb_type==I16MB || MbQ->mb_type==I8MB || MbQ->mb_type==IPCM) )
  449.       {
  450.         if( ((MbQ->cbp_blk &  ((int64)1 << blkQ )) != 0) || ((MbP->cbp_blk &  ((int64)1 << blkP)) != 0) )
  451.           Strength[idx] = 2 ;
  452.         else
  453.         {
  454.           // if no coefs, but vector difference >= 1 set Strength=1
  455.           // if this is a mixed mode edge then one set of reference pictures will be frame and the
  456.           // other will be field
  457.           if (mixedModeEdgeFlag)
  458.           {
  459.             (Strength[idx] = 1);
  460.           }
  461.           else
  462.           {
  463.             get_mb_block_pos (MbQAddr, &mb_x, &mb_y);
  464.             blk_y  = (mb_y<<2) + (blkQ >> 2) ;
  465.             blk_x  = (mb_x<<2) + (blkQ  & 3) ;
  466.             blk_y2 = pixP.pos_y >> 2;
  467.             blk_x2 = pixP.pos_x >> 2;
  468.             {
  469.               ref_p0 = list0_refIdxArr[blk_y ][blk_x ] < 0 ? INT64_MIN : list0_refPicIdArr[blk_y ][blk_x];
  470.               ref_q0 = list0_refIdxArr[blk_y2][blk_x2] < 0 ? INT64_MIN : list0_refPicIdArr[blk_y2][blk_x2];
  471.               ref_p1 = list1_refIdxArr[blk_y ][blk_x ] < 0 ? INT64_MIN : list1_refPicIdArr[blk_y ][blk_x];
  472.               ref_q1 = list1_refIdxArr[blk_y2][blk_x2]<0 ? INT64_MIN : list1_refPicIdArr[blk_y2][blk_x2];
  473.               if ( ((ref_p0==ref_q0) && (ref_p1==ref_q1)) ||
  474.                 ((ref_p0==ref_q1) && (ref_p1==ref_q0)))
  475.               {
  476.                 Strength[idx]=0;
  477.                 // L0 and L1 reference pictures of p0 are different; q0 as well
  478.                 if (ref_p0 != ref_p1)
  479.                 {
  480.                   // compare MV for the same reference picture
  481.                   if (ref_p0==ref_q0)
  482.                   {
  483.                     Strength[idx] =  (byte) (
  484.                       (iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  485.                       (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  486.                       (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  487.                       (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit));
  488.                   }
  489.                   else
  490.                   {
  491.                     Strength[idx] =  (byte) (
  492.                       (iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  493.                       (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  494.                       (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  495.                       (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit));
  496.                   }
  497.                 }
  498.                 else
  499.                 { // L0 and L1 reference pictures of p0 are the same; q0 as well
  501.                   Strength[idx] = (byte) (
  502.                     ((iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  503.                     (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit ) |
  504.                     (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  505.                     (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit))
  506.                     &&
  507.                     ((iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  508.                     (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  509.                     (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  510.                     (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit)));
  511.                 }
  512.               }
  513.               else
  514.               {
  515.                 Strength[idx] = 1;
  516.               }
  517.             }
  518.           }
  519.         }
  520.       }
  521.     }
  522.   }
  523. }
  525. /*!
  526.  *****************************************************************************************
  527.  * brief
  528.  *    Filters 16 pel block edge of Frame or Field coded MBs 
  529.  *****************************************************************************************
  530.  */
  531. void EdgeLoopLumaNormal(ColorPlane pl, imgpel** Img, byte Strength[16], ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset,
  532.               int dir, int edge, int width)
  533. { 
  534.   static imgpel   L2, L1, L0, R0, R1, R2, L3, R3;
  535.   static PixelPos pixP, pixQ, pixMB1, pixMB2;
  536.   static int      C0, tc0, dif, RL0;
  537.   static int      pel, ap, aq, Strng;
  538.   static int      Alpha, Beta, small_gap;
  539.   static int      indexA, indexB;
  540.   static int      QP;
  541.   static const byte* ClipTab;
  542.   static int incQ, incP;
  543.   int xQ = dir ? 0 : edge - 1;
  544.   int yQ = dir ? (edge < MB_BLOCK_SIZE ? edge - 1: 0) : 0;
  545.   int *mb_size = img->mb_size[IS_LUMA];
  547.   MbQ = &(img->mb_data[MbQAddr]); 
  548.   getNeighbour(MbQ, xQ, yQ, mb_size, &pixMB1);
  550.   if (pixMB1.available || (MbQ->DFDisableIdc== 0))
  551.   {
  552.     int  bitdepth_scale = pl ? img->bitdepth_scale[IS_CHROMA]: img->bitdepth_scale[IS_LUMA];
  553.     int  max_imgpel_value = img->max_imgpel_value_comp[pl];
  554.     pixP = pixMB1;
  555.     MbP  = &(img->mb_data[pixP.mb_addr]);
  556.     incQ = dir ? width : 1;
  557.     incP = incQ;
  558.     
  559.     yQ += dir;
  560.     xQ += (1 - dir);
  561.     getNeighbour(MbQ, xQ, yQ, mb_size, &pixMB2);
  562.     pixQ = pixMB2;
  564.     // Average QP of the two blocks
  565.     QP = pl? ((MbP->qpc[pl-1] + MbQ->qpc[pl-1] + 1) >> 1) : (MbP->qp + MbQ->qp + 1) >> 1;
  567.     indexA = iClip3(0, MAX_QP, QP + AlphaC0Offset);
  568.     indexB = iClip3(0, MAX_QP, QP + BetaOffset);
  570.     Alpha   = ALPHA_TABLE[indexA] * bitdepth_scale;
  571.     Beta    = BETA_TABLE [indexB] * bitdepth_scale;
  572.     ClipTab = CLIP_TAB[indexA];
  574.     for( pel = 0 ; pel < MB_BLOCK_SIZE ; pel++ )
  575.     {
  576.       if( (Strng = Strength[pel]) != 0)
  577.       {        
  578.       if (dir)
  579.       {
  580.         xQ         = pel;
  581.         pixP.x     = pixMB1.x + pel;
  582.         pixP.pos_x = pixMB1.pos_x + pel;
  583.         pixQ.x     = pixMB2.x + pel;
  584.         pixQ.pos_x = pixMB2.pos_x + pel;
  585.       }
  586.       else
  587.       {
  588.         yQ         = pel;
  589.         pixP.y     = pixMB1.y + pel;
  590.         pixP.pos_y = pixMB1.pos_y + pel;
  591.         pixQ.y     = pixMB2.y + pel;
  592.         pixQ.pos_y = pixMB2.pos_y + pel;
  593.       }
  595.         SrcPtrQ = &(Img[pixQ.pos_y][pixQ.pos_x]);
  596.         SrcPtrP = &(Img[pixP.pos_y][pixP.pos_x]);
  598.         L3 = *(SrcPtrP - incP * 3);
  599.         L2 = *(SrcPtrP - incP * 2);
  600.         L1 = *(SrcPtrP - incP);
  601.         L0 = *SrcPtrP;
  602.         R0 = *SrcPtrQ;
  603.         R1 = *(SrcPtrQ + incQ);
  604.         R2 = *(SrcPtrQ + incQ * 2);
  605.         R3 = *(SrcPtrQ + incQ * 3);
  607.         if( iabs( R0 - L0 ) < Alpha )
  608.         {
  609.           if ((iabs( R0 - R1) < Beta ) && (iabs(L0 - L1) < Beta ))
  610.           {            
  611.             if(Strng == 4 )    // INTRA strong filtering
  612.             {
  613.               RL0 = L0 + R0;
  614.               small_gap = (iabs( R0 - L0 ) < ((Alpha >> 2) + 2));
  615.               aq  = ( iabs( R0 - R2) < Beta ) & small_gap;
  616.               ap  = ( iabs( L0 - L2) < Beta ) & small_gap;
  618.               if (ap)
  619.               {
  620.                 *(SrcPtrP - incP*2) = (imgpel) ((((L3 + L2) <<1) + L2 + L1 + RL0 + 4) >> 3);
  621.                 *(SrcPtrP - incP)   = (imgpel)  (( L2 + L1 + RL0 + 2) >> 2);
  622.                 *SrcPtrP            = (imgpel)  (( R1 + ((L1 + RL0) << 1) +  L2 + 4) >> 3);
  623.               }
  624.               else
  625.               {
  626.                 *SrcPtrP = (imgpel) (((L1 << 1) + L0 + R1 + 2) >> 2) ;                
  627.               }
  629.               if (aq)
  630.               {
  631.                 *SrcPtrQ              = (imgpel) (( L1 + ((R1 + RL0) << 1) +  R2 + 4) >> 3);
  632.                 *(SrcPtrQ + incQ    ) = (imgpel) (( R2 + R0 + L0 + R1 + 2) >> 2);
  633.                 *(SrcPtrQ + incQ * 2) = (imgpel) ((((R3 + R2) <<1) + R2 + R1 + RL0 + 4) >> 3);
  634.               }
  635.               else
  636.               {
  637.                 *SrcPtrQ = (imgpel) (((R1 << 1) + R0 + L1 + 2) >> 2);
  638.               }
  639.             }
  640.             else   // normal filtering
  641.             {
  642.               RL0 = (L0 + R0 + 1) >> 1;
  643.               aq  = (iabs(R0 - R2) < Beta);
  644.               ap  = (iabs(L0 - L2) < Beta);
  645.               
  646.               C0  = ClipTab[ Strng ] * bitdepth_scale;
  647.               tc0  = (C0 + ap + aq) ;
  648.               dif = iClip3( -tc0, tc0, (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3 );
  650.               if( ap )
  651.                 *(SrcPtrP - incP) += iClip3( -C0,  C0, (L2 + RL0 - (L1<<1)) >> 1 );
  653.               *SrcPtrP = (imgpel) iClip3 (0, max_imgpel_value, L0 + dif);
  654.               *SrcPtrQ = (imgpel) iClip3 (0, max_imgpel_value, R0 - dif);
  656.               if( aq  )
  657.                 *(SrcPtrQ + incQ) += iClip3( -C0,  C0, (R2 + RL0 - (R1<<1)) >> 1 );
  658.             }            
  659.           }
  660.         }
  661.       }
  662.     }
  663.   }
  664. }
  666. /*!
  667.  *****************************************************************************************
  668.  * brief
  669.  *    Filters 16 pel block edge of Super MB Frame coded MBs
  670.  *****************************************************************************************
  671.  */
  672. void EdgeLoopLumaMBAff(ColorPlane pl, imgpel** Img, byte Strength[16], ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset,
  673.               int dir, int edge, int width)
  674. {
  675.   int      pel, ap = 0, aq = 0, Strng ;
  676.   int      incP, incQ;
  677.   int      C0, tc0, dif;
  678.   imgpel   L2 = 0, L1, L0, R0, R1, R2 = 0, L3, R3;
  679.   int      RL0;
  680.   int      Alpha = 0, Beta = 0 ;
  681.   const byte* ClipTab = NULL;
  682.   int      small_gap;
  683.   int      indexA, indexB;
  684.   int      PelNum  = MB_BLOCK_SIZE;
  685.   int      QP;
  686.   int      xQ, yQ;
  688.   PixelPos pixP, pixQ;
  689.   int      dir_m1 = (1 - dir);
  690.   int      bitdepth_scale = pl? img->bitdepth_scale[IS_CHROMA] : img->bitdepth_scale[IS_LUMA];
  691.   int      max_imgpel_value = img->max_imgpel_value_comp[pl];
  692.   int      *mb_size = img->mb_size[IS_LUMA];
  693.   
  694.   MbQ = &(img->mb_data[MbQAddr]);
  695.   
  696.   for( pel = 0 ; pel < PelNum ; pel++ )
  697.   {
  698.     xQ = dir ? pel : edge;
  699.     yQ = dir ? (edge < 16 ? edge : 1) : pel;    
  700.     getNeighbour(MbQ, xQ - (dir_m1), yQ - dir, mb_size, &pixP);
  701.     
  702.     if (pixP.available || (MbQ->DFDisableIdc== 0))
  703.     {
  704.       if( (Strng = Strength[pel]) != 0)
  705.       {
  706.         getNeighbour(MbQ, xQ, yQ, mb_size, &pixQ);
  707.         
  708.         MbP = &(img->mb_data[pixP.mb_addr]);
  709.         fieldModeFilteringFlag = (byte) (MbQ->mb_field || MbP->mb_field);
  711.         incQ    = dir ? ((fieldModeFilteringFlag && !MbQ->mb_field) ? 2 * width : width) : 1;
  712.         incP    = dir ? ((fieldModeFilteringFlag && !MbP->mb_field) ? 2 * width : width) : 1;
  713.         SrcPtrQ = &(Img[pixQ.pos_y][pixQ.pos_x]);
  714.         SrcPtrP = &(Img[pixP.pos_y][pixP.pos_x]);
  715.         
  716.         // Average QP of the two blocks
  717.         QP = pl? ((MbP->qpc[pl-1] + MbQ->qpc[pl-1] + 1) >> 1) : (MbP->qp + MbQ->qp + 1) >> 1;
  718.         
  719.         indexA = iClip3(0, MAX_QP, QP + AlphaC0Offset);
  720.         indexB = iClip3(0, MAX_QP, QP + BetaOffset);
  722.         Alpha   = ALPHA_TABLE[indexA] * bitdepth_scale;
  723.         Beta    = BETA_TABLE [indexB] * bitdepth_scale;
  724.         ClipTab = CLIP_TAB[indexA];
  726.         L3  = SrcPtrP[-incP*3];
  727.         L2  = SrcPtrP[-incP*2];
  728.         L1  = SrcPtrP[-incP];
  729.         L0  = SrcPtrP[0] ;
  730.         R0  = SrcPtrQ[0] ;      
  731.         R1  = SrcPtrQ[ incQ];      
  732.         R2  = SrcPtrQ[ incQ*2];
  733.         R3  = SrcPtrQ[ incQ*3];
  735.         if( iabs( R0 - L0 ) < Alpha )
  736.         {          
  737.           if ((iabs( R0 - R1) < Beta )   && (iabs(L0 - L1) < Beta ))
  738.           {            
  739.             if(Strng == 4 )    // INTRA strong filtering
  740.             {
  741.               RL0 = L0 + R0;
  742.               small_gap = (iabs( R0 - L0 ) < ((Alpha >> 2) + 2));
  743.               aq  = ( iabs( R0 - R2) < Beta ) & small_gap;               
  744.               ap  = ( iabs( L0 - L2) < Beta ) & small_gap;
  746.               if (ap)
  747.               {
  748.                 SrcPtrP[-incP*2] = (imgpel) ((((L3 + L2) << 1) + L2 + L1 + RL0 + 4) >> 3);
  749.                 SrcPtrP[-incP]   = (imgpel) (( L2 + L1 + L0 + R0 + 2) >> 2);
  750.                 SrcPtrP[0]       = (imgpel) (( R1 + ((L1 + RL0) << 1) +  L2 + 4) >> 3);
  751.               }
  752.               else
  753.               {
  754.                 SrcPtrP[ 0         ] = (imgpel) (((L1 << 1) + L0 + R1 + 2) >> 2) ;
  755.               }
  757.               if (aq)
  758.               {
  759.                 SrcPtrQ[ 0        ] = (imgpel) (( L1 + ((R1 + RL0) << 1) +  R2 + 4) >> 3);
  760.                 SrcPtrQ[ incQ     ] = (imgpel) (( R2 + R0 + R1 + L0 + 2) >> 2);
  761.                 SrcPtrQ[ incQ * 2 ] = (imgpel) ((((R3 + R2) << 1) + R2 + R1 + RL0 + 4) >> 3);
  762.               }
  763.               else
  764.               {
  765.                 SrcPtrQ[ 0        ] = (imgpel) (((R1 << 1) + R0 + L1 + 2) >> 2);
  766.               }
  767.             }
  768.             else   // normal filtering
  769.             {
  770.               RL0 = (L0 + R0 + 1) >> 1;
  771.               aq  = (iabs( R0 - R2) < Beta);
  772.               ap  = (iabs( L0 - L2) < Beta);
  774.               C0  = ClipTab[ Strng ] * bitdepth_scale;
  775.               tc0  = (C0 + ap + aq) ;
  776.               dif = iClip3( -tc0, tc0, (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3) ;
  778.               if( ap )
  779.                 *(SrcPtrP - incP) += iClip3( -C0,  C0, ( L2 + RL0 - (L1 << 1)) >> 1 ) ;
  781.               *SrcPtrP  = (imgpel) iClip1 (max_imgpel_value, L0 + dif) ;
  782.               *SrcPtrQ  = (imgpel) iClip1 (max_imgpel_value, R0 - dif) ;
  784.               if( aq  )
  785.                 *(SrcPtrQ + incQ) += iClip3( -C0,  C0, ( R2 + RL0 - (R1 << 1)) >> 1 ) ;
  786.             }            
  787.           }
  788.         }
  789.       }
  790.     }
  791.   }
  792. }
  794. /*!
  795.  *****************************************************************************************
  796.  * brief
  797.  *    Filters chroma block edge for Frame or Field coded pictures
  798.  *****************************************************************************************
  799.  */
  800. void EdgeLoopChromaNormal(imgpel** Img, byte Strength[16], ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset,
  801.               int dir, int edge, int width, int uv)
  802. {
  803.   static int      pel, Strng ;
  804.   static int      incP, incQ;
  805.   static int      tc0, dif;
  806.   static imgpel   L1, L0, R0, R1;
  807.   static int      Alpha, Beta;
  808.   static const byte* ClipTab;
  809.   static int      indexA, indexB;
  810.   int      PelNum = pelnum_cr[dir][img->yuv_format];
  811.   int      StrengthIdx;
  812.   static PixelPos pixP, pixQ, pixMB1, pixMB2;
  813.   static int      QP;
  814.   
  815.   int      bitdepth_scale = img->bitdepth_scale[IS_CHROMA];
  816.   int      max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  818.   int xQ = dir ? 0 : edge - 1;
  819.   int yQ = dir ? (edge < 16 ? edge - 1: 0) : 0;
  821.   MbQ = &(img->mb_data[MbQAddr]);
  822.   getNeighbour(MbQ, xQ, yQ, img->mb_size[IS_CHROMA], &pixMB1);
  824.   if (pixMB1.available || (MbQ->DFDisableIdc == 0))
  825.   {
  826.     pixP = pixMB1;
  827.     MbP = &(img->mb_data[pixP.mb_addr]);
  828.     yQ += dir;
  829.     xQ += (1 - dir);
  831.     getNeighbour(MbQ, xQ, yQ, img->mb_size[IS_CHROMA], &pixMB2);
  832.     pixQ = pixMB2;
  834.     // Average QP of the two blocks
  835.     QP = (MbP->qpc[uv] + MbQ->qpc[uv] + 1) >> 1;
  837.     indexA = iClip3(0, MAX_QP, QP + AlphaC0Offset);
  838.     indexB = iClip3(0, MAX_QP, QP + BetaOffset);
  840.     Alpha   = ALPHA_TABLE[indexA] * bitdepth_scale;
  841.     Beta    = BETA_TABLE [indexB] * bitdepth_scale;
  842.     ClipTab = CLIP_TAB[indexA];
  844.     for( pel = 0 ; pel < PelNum ; pel++ )
  845.     {
  846.       StrengthIdx = (PelNum == 8) ? (((pel >> 1) << 2) + (pel & 0x01)) : pel;
  848.       if( (Strng = Strength[StrengthIdx]) != 0)
  849.       {
  850.       if (dir)
  851.       {
  852.         xQ         = pel;
  853.         pixP.x     = pixMB1.x + pel;
  854.         pixP.pos_x = pixMB1.pos_x + pel;
  855.         pixQ.x     = pixMB2.x + pel;
  856.         pixQ.pos_x = pixMB2.pos_x + pel;
  857.       }
  858.       else
  859.       {
  860.         yQ         = pel;
  861.         pixP.y     = pixMB1.y + pel;
  862.         pixP.pos_y = pixMB1.pos_y + pel;
  863.         pixQ.y     = pixMB2.y + pel;
  864.         pixQ.pos_y = pixMB2.pos_y + pel;
  865.       }
  867.         incQ = dir ? width : 1;
  868.         incP = dir ? width : 1;
  870.         SrcPtrP = &(Img[pixP.pos_y][pixP.pos_x]);
  871.         L1  = *(SrcPtrP - incP);
  872.         L0  = *SrcPtrP;
  873.         SrcPtrQ = &(Img[pixQ.pos_y][pixQ.pos_x]);
  874.         R0  = *SrcPtrQ;
  875.         R1  = *(SrcPtrQ + incQ);
  877.         if (( iabs( R0 - L0 ) < Alpha ) && ( iabs(R0 - R1) < Beta )  && ( iabs(L0 - L1) < Beta )  )
  878.           {
  879.             if( Strng == 4 )    // INTRA strong filtering
  880.             {
  881.               *SrcPtrP = (imgpel) ( ((L1 << 1) + L0 + R1 + 2) >> 2 );
  882.               *SrcPtrQ = (imgpel) ( ((R1 << 1) + R0 + L1 + 2) >> 2 );
  883.             }
  884.             else
  885.             {
  886.               tc0  = ClipTab[ Strng ] * bitdepth_scale + 1;
  887.               dif = iClip3( -tc0, tc0, ( ((R0 - L0) << 2) + (L1 - R1) + 4) >> 3 );
  889.               *SrcPtrP = (imgpel) iClip1 ( max_imgpel_value_uv, L0 + dif) ;
  890.               *SrcPtrQ = (imgpel) iClip1 ( max_imgpel_value_uv, R0 - dif) ;
  891.             }          
  892.         }
  893.       }
  894.     }
  895.   }
  896. }
  898. /*!
  899. *****************************************************************************************
  900. * brief
  901. *    Filters chroma block edge for MBAFF types
  902. *****************************************************************************************
  903.  */
  904. void EdgeLoopChromaMBAff(imgpel** Img, byte Strength[16], ImageParameters *img, int MbQAddr, int AlphaC0Offset, int BetaOffset,
  905.               int dir, int edge, int width, int uv)
  906. {
  907.   int      pel, Strng ;
  908.   int      incP, incQ;
  909.   int      C0, tc0,  dif;
  910.   imgpel   L1, L0, R0, R1;
  911.   int      Alpha = 0, Beta = 0;
  912.   const byte* ClipTab = NULL;
  913.   int      indexA, indexB;
  914.   int      PelNum = pelnum_cr[dir][img->yuv_format];
  915.   int      StrengthIdx;
  916.   int      QP;
  917.   int      xQ, yQ;
  918.   PixelPos pixP, pixQ;
  919.   int      dir_m1 = 1 - dir;
  920.   int      bitdepth_scale = img->bitdepth_scale[IS_CHROMA];
  921.   int      max_imgpel_value_uv = img->max_imgpel_value_comp[1];
  923.   MbQ = &(img->mb_data[MbQAddr]);
  924.   for( pel = 0 ; pel < PelNum ; pel++ )
  925.   {
  926.     xQ = dir ? pel : edge;
  927.     yQ = dir ? (edge < 16? edge : 1) : pel;
  928.     getNeighbour(MbQ, xQ, yQ, img->mb_size[IS_CHROMA], &pixQ);
  929.     getNeighbour(MbQ, xQ - (dir_m1), yQ - dir, img->mb_size[IS_CHROMA], &pixP);    
  930.     MbP = &(img->mb_data[pixP.mb_addr]);    
  931.     StrengthIdx = (PelNum == 8) ? ((MbQ->mb_field && !MbP->mb_field) ? pel << 1 :((pel >> 1) << 2) + (pel & 0x01)) : pel;
  933.     if (pixP.available || (MbQ->DFDisableIdc == 0))
  934.     {
  935.       if( (Strng = Strength[StrengthIdx]) != 0)
  936.       {
  937.         fieldModeFilteringFlag = (byte) (MbQ->mb_field || MbP->mb_field);
  938.         incQ = dir ? ((fieldModeFilteringFlag && !MbQ->mb_field) ? 2 * width : width) : 1;
  939.         incP = dir ? ((fieldModeFilteringFlag && !MbP->mb_field) ? 2 * width : width) : 1;
  940.         SrcPtrQ = &(Img[pixQ.pos_y][pixQ.pos_x]);
  941.         SrcPtrP = &(Img[pixP.pos_y][pixP.pos_x]);
  943.         // Average QP of the two blocks
  944.         QP = (MbP->qpc[uv] + MbQ->qpc[uv] + 1) >> 1;
  946.         indexA = iClip3(0, MAX_QP, QP + AlphaC0Offset);
  947.         indexB = iClip3(0, MAX_QP, QP + BetaOffset);
  949.         Alpha   = ALPHA_TABLE[indexA] * bitdepth_scale;
  950.         Beta    = BETA_TABLE [indexB] * bitdepth_scale;
  951.         ClipTab = CLIP_TAB[indexA];
  953.         L1  = SrcPtrP[-incP];
  954.         L0  = SrcPtrP[0] ;
  955.         R0  = SrcPtrQ[0] ;      
  956.         R1  = SrcPtrQ[ incQ];      
  958.         if( iabs( R0 - L0 ) < Alpha )
  959.         {
  960.           if( ((iabs( R0 - R1) - Beta )  & (iabs(L0 - L1) - Beta )) < 0  )
  961.           {
  962.             if( Strng == 4 )    // INTRA strong filtering
  963.             {
  964.               SrcPtrQ[0] = (imgpel) ( ((R1 << 1) + R0 + L1 + 2) >> 2 );
  965.               SrcPtrP[0] = (imgpel) ( ((L1 << 1) + L0 + R1 + 2) >> 2 );
  966.             }
  967.             else
  968.             {
  969.               C0  = ClipTab[ Strng ] * bitdepth_scale;
  970.               tc0  = (C0 + 1);
  971.               dif = iClip3( -tc0, tc0, ( ((R0 - L0) << 2) + (L1 - R1) + 4) >> 3 );
  973.               SrcPtrP[0] = (imgpel) iClip1 ( max_imgpel_value_uv, L0 + dif) ;
  974.               SrcPtrQ[0] = (imgpel) iClip1 ( max_imgpel_value_uv, R0 - dif) ;
  975.             }
  976.           }
  977.         }
  978.       }
  979.     }
  980.   }
  981. }
  983. int compute_deblock_strength(char **list0_refIdxArr, 
  984.                              char **list1_refIdxArr, 
  985.                              int64 **list0_refPicIdArr, 
  986.                              int64 **list1_refPicIdArr, 
  987.                              short  ***list0_mv,
  988.                              short  ***list1_mv,
  989.                              int blk_y, int blk_x, 
  990.                              int blk_y2, int blk_x2, 
  991.                              int mvlimit)
  992. {
  993.   static int64 ref_p0, ref_q0, ref_p1, ref_q1;
  994.   static byte StrValue;
  996.   ref_p0 = list0_refIdxArr[blk_y] [blk_x] <0 ? INT64_MIN : list0_refPicIdArr[blk_y] [blk_x];
  997.   ref_q0 = list0_refIdxArr[blk_y2][blk_x2]<0 ? INT64_MIN : list0_refPicIdArr[blk_y2][blk_x2];
  998.   ref_p1 = list1_refIdxArr[blk_y] [blk_x] <0 ? INT64_MIN : list1_refPicIdArr[blk_y] [blk_x];
  999.   ref_q1 = list1_refIdxArr[blk_y2][blk_x2]<0 ? INT64_MIN : list1_refPicIdArr[blk_y2][blk_x2];
  1000.   if ( ((ref_p0==ref_q0) && (ref_p1==ref_q1)) || ((ref_p0==ref_q1) && (ref_p1==ref_q0)))
  1001.   {
  1002.     // L0 and L1 reference pictures of p0 are different; q0 as well
  1003.     if (ref_p0 != ref_p1)
  1004.     {
  1005.       // compare MV for the same reference picture
  1006.       if (ref_p0 == ref_q0)
  1007.       {
  1008.         StrValue =  (byte) (
  1009.           (iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  1010.           (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  1011.           (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  1012.           (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit));                  
  1013.       }
  1014.       else
  1015.       {
  1016.         StrValue =  (byte) (
  1017.           (iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  1018.           (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  1019.           (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  1020.           (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit));
  1021.       }
  1022.     }
  1023.     else
  1024.     { // L0 and L1 reference pictures of p0 are the same; q0 as well
  1026.       StrValue = (byte) (
  1027.         ((iabs( list0_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  1028.         (iabs( list0_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit ) |
  1029.         (iabs( list1_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  1030.         (iabs( list1_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit))
  1031.         &&
  1032.         ((iabs( list0_mv[blk_y][blk_x][0] - list1_mv[blk_y2][blk_x2][0]) >= 4) |
  1033.         (iabs( list0_mv[blk_y][blk_x][1] - list1_mv[blk_y2][blk_x2][1]) >= mvlimit) |
  1034.         (iabs( list1_mv[blk_y][blk_x][0] - list0_mv[blk_y2][blk_x2][0]) >= 4) |
  1035.         (iabs( list1_mv[blk_y][blk_x][1] - list0_mv[blk_y2][blk_x2][1]) >= mvlimit)));
  1036.     }
  1037.   }
  1038.   else
  1039.   {
  1040.     StrValue = 1;
  1041.   }
  1042.  return StrValue;
  1043. }