📄 loopfilter.cpp
字号:
/*!
*************************************************************************************
* \file loopFilter.c
*
* \brief
* Filter to reduce blocking artifacts on a macroblock level.
* The filter strengh is QP dependent.
*
* \author
* Contributors:
* - Peter List Peter.List@t-systems.de: Original code (13-Aug-2001)
* - Jani Lainema Jani.Lainema@nokia.com: Some bug fixing, removal of recusiveness (16-Aug-2001)
* - Peter List Peter.List@t-systems.de: inplace filtering and various simplifications (10-Jan-2002)
* - Anthony Joch anthony@ubvideo.com: Simplified switching between filters and
* non-recursive default filter. (08-Jul-2002)
* - Cristina Gomila cristina.gomila@thomson.net: Simplification of the chroma deblocking
* from JVT-E089 (21-Nov-2002)
*************************************************************************************
*/
#include <stdlib.h>
#include <string.h>
#include "global.h"
#include "image.h"
#include "mb_access.h"
#include "macroblock.h"
/*********************************************************************************************************/
#define IClip( Min, Max, Val) (((Val)<(Min))? (Min):(((Val)>(Max))? (Max):(Val)))
// NOTE: to change the tables below for instance when the QP doubling is changed from 6 to 8 values
// send an e-mail to Peter.List@t-systems.com to get a little programm that calculates them automatically
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} ;
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} ;
byte CLIP_TAB[52][5] =
{
{ 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},
{ 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},
{ 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},
{ 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},
{ 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},
{ 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},
{ 0, 9,12,18,18},{ 0,10,13,20,20},{ 0,11,15,23,23},{ 0,13,17,25,25}
} ;
void GetStrength(byte Strength[16],struct img_par *img,int MbQAddr,int dir,int edge, int mvlimit);
//void EdgeLoop(byte** Img, byte Strength[16],struct img_par *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width, int yuv);
void EdgeLoopLuma(byte** Img, byte Strength[16],struct img_par *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width);
void EdgeLoopChroma(byte** Img, byte Strength[16],struct img_par *img, int MbQAddr, int AlphaC0Offset, int BetaOffset, int dir, int edge, int width);
void DeblockMb(ImageParameters *img, byte **imgY, byte ***imgUV, int MbQAddr) ;
/*!
*****************************************************************************************
* \brief
* Filter all macroblocks in order of increasing macroblock address.
*****************************************************************************************
*/
void DeblockFrame(ImageParameters *img, byte **imgY, byte ***imgUV)
{
unsigned i;
unsigned PicSizeInMbs=img->PicSizeInMbs;
for (i=0; i<PicSizeInMbs; i++)
{
DeblockMb( img, imgY, imgUV, i ) ;
}
}
/*!
*****************************************************************************************
* \brief
* Deblocking filter for one macroblock.
*****************************************************************************************
*/
void DeblockMb(ImageParameters *img, byte **imgY, byte ***imgUV, int MbQAddr)
{
int EdgeCondition;
int dir,edge;
byte Strength[16];
int mb_x, mb_y;
int filterLeftMbEdgeFlag;
int filterTopMbEdgeFlag;
int mvlimit=4;
int i, StrengthSum;
Macroblock *MbQ;
img->DeblockCall = 1;
get_mb_pos (MbQAddr, &mb_x, &mb_y);
filterLeftMbEdgeFlag = (mb_x != 0);
filterTopMbEdgeFlag = (mb_y != 0);
MbQ = &(img->mb_data[MbQAddr]) ; // current Mb
// return, if filter is disabled
if (MbQ->LFDisableIdc==1) {
img->DeblockCall = 0;
return;
}
if (MbQ->LFDisableIdc==2)
{
// don't filter at slice boundaries
filterLeftMbEdgeFlag = MbQ->mbAvailA;
filterTopMbEdgeFlag = MbQ->mbAvailB;;
}
img->current_mb_nr = MbQAddr;
CheckAvailabilityOfNeighbors();
for( dir=0 ; dir<2 ; dir++ ) // vertical edges, than horicontal edges
{
EdgeCondition = (dir && filterTopMbEdgeFlag) || (!dir && filterLeftMbEdgeFlag); // can not filter beyond picture boundaries
for( edge=0 ; edge<4 ; edge++ ) // first 4 vertical strips of 16 pel
{ // then 4 horicontal
if( edge || EdgeCondition )
{
GetStrength(Strength,img,MbQAddr,dir,edge, mvlimit); // Strength for 4 blks in 1 stripe
StrengthSum = Strength[0];
for (i = 1; i < 16; i++) StrengthSum += Strength[i];
if( StrengthSum ) // only if one of the 16 Strength bytes is != 0
{
EdgeLoopLuma( imgY, Strength, img, MbQAddr, MbQ->LFAlphaC0Offset, MbQ->LFBetaOffset, dir, edge, img->width) ;
if( (imgUV != NULL) && !(edge & 1) )
{
EdgeLoopChroma( imgUV[0], Strength, img, MbQAddr, MbQ->LFAlphaC0Offset, MbQ->LFBetaOffset, dir, edge/2, img->width_cr ) ;
EdgeLoopChroma( imgUV[1], Strength, img, MbQAddr, MbQ->LFAlphaC0Offset, MbQ->LFBetaOffset, dir, edge/2, img->width_cr ) ;
}
}
}
}//end edge
}//end loop dir
img->DeblockCall = 0;
}
/*!
*********************************************************************************************
* \brief
* returns a buffer of 16 Strength values for one stripe in a mb (for different Frame types)
*********************************************************************************************
*/
void GetStrength(byte Strength[16],struct img_par *img,int MbQAddr,int dir,int edge, int mvlimit)
{
int blkP, blkQ, idx;
int blk_x, blk_x2, blk_y, blk_y2 ;
int ***list0_mv = dec_picture->mv[LIST_0];
int **list0_refIdxArr = dec_picture->ref_idx[LIST_0];
int64 **list0_refPicIdArr = dec_picture->ref_pic_id[LIST_0];
int xQ, xP, yQ, yP;
int mb_x, mb_y;
Macroblock *MbQ;
Macroblock *MbP;
PixelPos pixP;
MbQ = &(img->mb_data[MbQAddr]);
for( idx=0 ; idx<16 ; idx++ )
{
xQ = dir ? idx : edge << 2;
yQ = dir ? (edge < 4 ? edge << 2 : 1) : idx;
getLumaNeighbour(MbQAddr, xQ - (1 - dir), yQ - dir,&pixP);
xP = pixP.x;
yP = pixP.y;
MbP = &(img->mb_data[pixP.mb_addr]);
blkQ = ((yQ>>2)<<2) + (xQ>>2);
blkP = ((yP>>2)<<2) + (xP>>2);
// Start with Strength=3. or Strength=4 for Mb-edge
Strength[idx] = (edge == 0 ) ? 4 : 3;
if( !(MbP->mb_type==I4MB || MbP->mb_type==I16MB || MbP->mb_type==IPCM)
&& !(MbQ->mb_type==I4MB || MbQ->mb_type==I16MB || MbQ->mb_type==IPCM) )
{
if( ((MbQ->cbp_blk & (1 << blkQ )) != 0) || ((MbP->cbp_blk & (1 << blkP)) != 0) )
Strength[idx] = 2 ;
else
{ // if no coefs, but vector difference >= 1 set Strength=1
// if this is a mixed mode edge then one set of reference pictures will be frame and the
// other will be field
get_mb_block_pos (MbQAddr, &mb_x, &mb_y);
blk_y = (mb_y<<2) + (blkQ >> 2) ;
blk_x = (mb_x<<2) + (blkQ & 3) ;
blk_y2 = pixP.pos_y >> 2;
blk_x2 = pixP.pos_x >> 2;
// P slice
int64 ref_p0,ref_q0;
ref_p0 = list0_refIdxArr[blk_x][blk_y]<0 ? -1 : list0_refPicIdArr[blk_x][blk_y];
ref_q0 = list0_refIdxArr[blk_x2][blk_y2]<0 ? -1 : list0_refPicIdArr[blk_x2][blk_y2];
Strength[idx] = (ref_p0 != ref_q0 ) |
(abs( list0_mv[blk_x][blk_y][0] - list0_mv[blk_x2][blk_y2][0]) >= 4 ) |
(abs( list0_mv[blk_x][blk_y][1] - list0_mv[blk_x2][blk_y2][1]) >= mvlimit );
}
}
}
}
extern pic_parameter_set_rbsp_t *active_pps;
#define CQPOF(qp) (Clip3(0, 51, qp + active_pps->chroma_qp_index_offset))
/*!
*****************************************************************************************
* \brief
* Filters one edge of 16 (luma) or 8 (chroma) pel
*****************************************************************************************
*/
/*void EdgeLoop(byte** Img, byte Strength[16],struct img_par *img, int MbQAddr, int AlphaC0Offset, int BetaOffset,
int dir, int edge, int width, int yuv)
{
int pel, ap = 0, aq = 0, Strng ;
int incP, incQ;
int C0, c0, Delta, dif, AbsDelta ;
int L2 = 0, L1, L0, R0, R1, R2 = 0, RL0, L3, R3 ;
int Alpha = 0, Beta = 0 ;
byte* ClipTab = NULL;
int small_gap;
int indexA, indexB;
int PelNum;
int StrengthIdx;
byte *SrcPtrP, *SrcPtrQ;
int QP;
int xP, xQ, yP, yQ;
Macroblock *MbQ, *MbP;
PixelPos pixP, pixQ;
PelNum = yuv ? 8 : 16 ;
for( pel=0 ; pel<PelNum ; pel++ )
{
xQ = dir ? pel : edge << 2;
yQ = dir ? (edge < 4 ? edge << 2 : 1) : pel;
if(!yuv)
{
getLumaNeighbour(MbQAddr, xQ, yQ, &pixQ);
getLumaNeighbour(MbQAddr, xQ - (1 - dir), yQ - dir, &pixP);
}
else
{
getChromaNeighbour(MbQAddr, xQ, yQ, &pixQ);
getChromaNeighbour(MbQAddr, xQ - (1 - dir), yQ - dir, &pixP);
}
xP = pixP.x;
yP = pixP.y;
MbQ = &(img->mb_data[MbQAddr]);
MbP = &(img->mb_data[pixP.mb_addr]);
StrengthIdx = yuv ? (((pel>>1)<<2)+(pel&0x0001)) : pel ;
if (pixP.available || (MbQ->LFDisableIdc== 0)) {
incQ = dir ? width : 1;
incP = dir ? width : 1;
SrcPtrQ = &(Img[pixQ.pos_y][pixQ.pos_x]);
SrcPtrP = &(Img[pixP.pos_y][pixP.pos_x]);
// Average QP of the two blocks
QP = yuv ? (QP_SCALE_CR[CQPOF(MbP->qp)] + QP_SCALE_CR[CQPOF(MbQ->qp)] + 1) >> 1 : (MbP->qp + MbQ->qp + 1) >> 1;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -