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

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

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