PageRenderTime 950ms CodeModel.GetById 161ms app.highlight 711ms RepoModel.GetById 16ms app.codeStats 3ms

/Avc/deblock.cpp

http://github.com/mbebenita/Broadway
C++ | 1667 lines | 1222 code | 272 blank | 173 comment | 354 complexity | fb2b58931080867affc66a4e435964ff MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/* ------------------------------------------------------------------
   2 * Copyright (C) 1998-2009 PacketVideo
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *      http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13 * express or implied.
  14 * See the License for the specific language governing permissions
  15 * and limitations under the License.
  16 * -------------------------------------------------------------------
  17 */
  18
  19#include <string.h>
  20
  21#include "avclib_common.h"
  22
  23#define MAX_QP 51
  24#define MB_BLOCK_SIZE 16
  25
  26// NOTE: these 3 tables are for funtion GetStrength() only
  27const static int ININT_STRENGTH[4] = {0x04040404, 0x03030303, 0x03030303, 0x03030303};
  28
  29
  30// NOTE: these 3 tables are for funtion EdgeLoop() only
  31// NOTE: to change the tables below for instance when the QP doubling is changed from 6 to 8 values
  32
  33const static int 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} ;
  34const static int 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} ;
  35const static int CLIP_TAB[52][5]  =
  36{
  37    { 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},
  38    { 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},
  39    { 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},
  40    { 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},
  41    { 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},
  42    { 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},
  43    { 0, 9, 12, 18, 18}, { 0, 10, 13, 20, 20}, { 0, 11, 15, 23, 23}, { 0, 13, 17, 25, 25}
  44};
  45
  46// NOTE: this table is only QP clipping, index = QP + video->FilterOffsetA/B, clipped to [0, 51]
  47//       video->FilterOffsetA/B is in {-12, 12]
  48const static int QP_CLIP_TAB[76] =
  49{
  50    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,              // [-12, 0]
  51    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
  52    13, 14, 15, 16, 17, 18, 19, 20, 21,
  53    22, 23, 24, 25, 26, 27, 28, 29, 30,
  54    31, 32, 33, 34, 35, 36, 37, 38, 39,
  55    40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // [1, 51]
  56    51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51      // [52,63]
  57};
  58
  59static void DeblockMb(AVCCommonObj *video, int mb_x, int mb_y, uint8 *SrcY, uint8 *SrcU, uint8 *SrcV);
  60//static void GetStrength(AVCCommonObj *video, uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir, int edge);
  61static void GetStrength_Edge0(uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir);
  62static void GetStrength_VerticalEdges(uint8 *Strength, AVCMacroblock* MbQ);
  63static void GetStrength_HorizontalEdges(uint8 Strength[12], AVCMacroblock* MbQ);
  64static void EdgeLoop_Luma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
  65static void EdgeLoop_Luma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
  66static void EdgeLoop_Chroma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
  67static void EdgeLoop_Chroma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
  68
  69/*
  70 *****************************************************************************************
  71 * \brief Filter all macroblocks in order of increasing macroblock address.
  72 *****************************************************************************************
  73*/
  74
  75OSCL_EXPORT_REF AVCStatus DeblockPicture(AVCCommonObj *video)
  76{
  77    uint   i, j;
  78    int   pitch = video->currPic->pitch, pitch_c, width;
  79    uint8 *SrcY, *SrcU, *SrcV;
  80
  81    SrcY = video->currPic->Sl;      // pointers to source
  82    SrcU = video->currPic->Scb;
  83    SrcV = video->currPic->Scr;
  84    pitch_c = pitch >> 1;
  85    width = video->currPic->width;
  86
  87    for (i = 0; i < video->PicHeightInMbs; i++)
  88    {
  89        for (j = 0; j < video->PicWidthInMbs; j++)
  90        {
  91            DeblockMb(video, j, i, SrcY, SrcU, SrcV);
  92            // update SrcY, SrcU, SrcV
  93            SrcY += MB_BLOCK_SIZE;
  94            SrcU += (MB_BLOCK_SIZE >> 1);
  95            SrcV += (MB_BLOCK_SIZE >> 1);
  96        }
  97
  98        SrcY += ((pitch << 4) - width);
  99        SrcU += ((pitch_c << 3) - (width >> 1));
 100        SrcV += ((pitch_c << 3) - (width >> 1));
 101    }
 102
 103    return AVC_SUCCESS;
 104}
 105
 106#ifdef MB_BASED_DEBLOCK
 107/*
 108 *****************************************************************************************
 109 * \brief Filter one macroblocks in a fast macroblock memory and copy it to frame
 110 *****************************************************************************************
 111*/
 112void MBInLoopDeblock(AVCCommonObj *video)
 113{
 114    AVCPictureData *currPic = video->currPic;
 115#ifdef USE_PRED_BLOCK
 116    uint8 *predCb, *predCr, *pred_block;
 117    int i, j, dst_width, dst_height, dst_widthc, dst_heightc;
 118#endif
 119    int pitch = currPic->pitch;
 120    int x_pos = video->mb_x;
 121    int y_pos = video->mb_y;
 122    uint8 *curL, *curCb, *curCr;
 123    int offset;
 124
 125    offset = (y_pos << 4) * pitch;
 126
 127    curL = currPic->Sl + offset + (x_pos << 4);
 128
 129    offset >>= 2;
 130    offset += (x_pos << 3);
 131
 132    curCb = currPic->Scb + offset;
 133    curCr = currPic->Scr + offset;
 134
 135#ifdef USE_PRED_BLOCK
 136    pred_block = video->pred;
 137
 138    /* 1. copy neighboring pixels from frame to the video->pred_block */
 139    if (y_pos) /* not the 0th row */
 140    {
 141        /* copy to the top 4 lines of the macroblock */
 142        curL -= (pitch << 2); /* go back 4 lines */
 143
 144        memcpy(pred_block + 4, curL, 16);
 145        curL += pitch;
 146        memcpy(pred_block + 24, curL, 16);
 147        curL += pitch;
 148        memcpy(pred_block + 44, curL, 16);
 149        curL += pitch;
 150        memcpy(pred_block + 64, curL, 16);
 151        curL += pitch;
 152
 153        curCb -= (pitch << 1); /* go back 4 lines chroma */
 154        curCr -= (pitch << 1);
 155
 156        pred_block += 400;
 157
 158        memcpy(pred_block + 4, curCb, 8);
 159        curCb += (pitch >> 1);
 160        memcpy(pred_block + 16, curCb, 8);
 161        curCb += (pitch >> 1);
 162        memcpy(pred_block + 28, curCb, 8);
 163        curCb += (pitch >> 1);
 164        memcpy(pred_block + 40, curCb, 8);
 165        curCb += (pitch >> 1);
 166
 167        pred_block += 144;
 168        memcpy(pred_block + 4, curCr, 8);
 169        curCr += (pitch >> 1);
 170        memcpy(pred_block + 16, curCr, 8);
 171        curCr += (pitch >> 1);
 172        memcpy(pred_block + 28, curCr, 8);
 173        curCr += (pitch >> 1);
 174        memcpy(pred_block + 40, curCr, 8);
 175        curCr += (pitch >> 1);
 176
 177        pred_block = video->pred;
 178    }
 179
 180    /* 2. perform deblocking. */
 181    DeblockMb(video, x_pos, y_pos, pred_block + 84, pred_block + 452, pred_block + 596);
 182
 183    /* 3. copy it back to the frame and update pred_block */
 184    predCb = pred_block + 400;
 185    predCr = predCb + 144;
 186
 187    /* find the range of the block inside pred_block to be copied back */
 188    if (y_pos)  /* the first row */
 189    {
 190        curL -= (pitch << 2);
 191        curCb -= (pitch << 1);
 192        curCr -= (pitch << 1);
 193
 194        dst_height = 20;
 195        dst_heightc = 12;
 196    }
 197    else
 198    {
 199        pred_block += 80;
 200        predCb += 48;
 201        predCr += 48;
 202        dst_height = 16;
 203        dst_heightc = 8;
 204    }
 205
 206    if (x_pos) /* find the width */
 207    {
 208        curL -= 4;
 209        curCb -= 4;
 210        curCr -= 4;
 211        if (x_pos == (int)(video->PicWidthInMbs - 1))
 212        {
 213            dst_width = 20;
 214            dst_widthc = 12;
 215        }
 216        else
 217        {
 218            dst_width = 16;
 219            dst_widthc = 8;
 220        }
 221    }
 222    else
 223    {
 224        pred_block += 4;
 225        predCb += 4;
 226        predCr += 4;
 227        dst_width = 12;
 228        dst_widthc = 4;
 229    }
 230
 231    /* perform copy */
 232    for (j = 0; j < dst_height; j++)
 233    {
 234        memcpy(curL, pred_block, dst_width);
 235        curL += pitch;
 236        pred_block += 20;
 237    }
 238    for (j = 0; j < dst_heightc; j++)
 239    {
 240        memcpy(curCb, predCb, dst_widthc);
 241        memcpy(curCr, predCr, dst_widthc);
 242        curCb += (pitch >> 1);
 243        curCr += (pitch >> 1);
 244        predCb += 12;
 245        predCr += 12;
 246    }
 247
 248    if (x_pos != (int)(video->PicWidthInMbs - 1)) /* now copy from the right-most 4 columns to the left-most 4 columns */
 249    {
 250        pred_block = video->pred;
 251        for (i = 0; i < 20; i += 4)
 252        {
 253            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
 254            pred_block += 20;
 255            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
 256            pred_block += 20;
 257            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
 258            pred_block += 20;
 259            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
 260            pred_block += 20;
 261        }
 262
 263        for (i = 0; i < 24; i += 4)
 264        {
 265            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
 266            pred_block += 12;
 267            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
 268            pred_block += 12;
 269            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
 270            pred_block += 12;
 271            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
 272            pred_block += 12;
 273        }
 274
 275    }
 276#else
 277    DeblockMb(video, x_pos, y_pos, curL, curCb, curCr);
 278#endif
 279
 280    return ;
 281}
 282#endif
 283
 284/*
 285 *****************************************************************************************
 286 * \brief Deblocking filter for one macroblock.
 287 *****************************************************************************************
 288 */
 289
 290void DeblockMb(AVCCommonObj *video, int mb_x, int mb_y, uint8 *SrcY, uint8 *SrcU, uint8 *SrcV)
 291{
 292    AVCMacroblock *MbP, *MbQ;
 293    int     edge, QP, QPC;
 294    int     filterLeftMbEdgeFlag = (mb_x != 0);
 295    int     filterTopMbEdgeFlag  = (mb_y != 0);
 296    int     pitch = video->currPic->pitch;
 297    int     indexA, indexB;
 298    uintptr_t tmp;
 299    int     Alpha, Beta, Alpha_c, Beta_c;
 300    int     mbNum = mb_y * video->PicWidthInMbs + mb_x;
 301    int     *clipTable, *clipTable_c, *qp_clip_tab;
 302    uint8   Strength[16];
 303    void*     str;
 304
 305    MbQ = &(video->mblock[mbNum]);      // current Mb
 306
 307
 308    // If filter is disabled, return
 309    if (video->sliceHdr->disable_deblocking_filter_idc == 1) return;
 310
 311    if (video->sliceHdr->disable_deblocking_filter_idc == 2)
 312    {
 313        // don't filter at slice boundaries
 314        filterLeftMbEdgeFlag = mb_is_available(video->mblock, video->PicSizeInMbs, mbNum - 1, mbNum);
 315        filterTopMbEdgeFlag  = mb_is_available(video->mblock, video->PicSizeInMbs, mbNum - video->PicWidthInMbs, mbNum);
 316    }
 317
 318    /* NOTE: edge=0 and edge=1~3 are separate cases because of the difference of MbP, index A and indexB calculation */
 319    /*       for edge = 1~3, MbP, indexA and indexB remain the same, and thus there is no need to re-calculate them for each edge */
 320
 321    qp_clip_tab = (int *)QP_CLIP_TAB + 12;
 322
 323    /* 1.VERTICAL EDGE + MB BOUNDARY (edge = 0) */
 324    if (filterLeftMbEdgeFlag)
 325    {
 326        MbP = MbQ - 1;
 327        //GetStrength(video, Strength, MbP, MbQ, 0, 0); // Strength for 4 blks in 1 stripe, 0 => vertical edge
 328        GetStrength_Edge0(Strength, MbP, MbQ, 0);
 329
 330        str = (void*)Strength; //de-ref type-punned pointer fix
 331        if (*((uint32*)str))    // only if one of the 4 Strength bytes is != 0
 332        {
 333            QP = (MbP->QPy + MbQ->QPy + 1) >> 1; // Average QP of the two blocks;
 334            indexA = QP + video->FilterOffsetA;
 335            indexB = QP + video->FilterOffsetB;
 336            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 337            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 338
 339            Alpha  = ALPHA_TABLE[indexA];
 340            Beta = BETA_TABLE[indexB];
 341            clipTable = (int *) CLIP_TAB[indexA];
 342
 343            if (Alpha > 0 && Beta > 0)
 344#ifdef USE_PRED_BLOCK
 345                EdgeLoop_Luma_vertical(SrcY, Strength,  Alpha, Beta, clipTable, 20);
 346#else
 347                EdgeLoop_Luma_vertical(SrcY, Strength,  Alpha, Beta, clipTable, pitch);
 348#endif
 349
 350            QPC = (MbP->QPc + MbQ->QPc + 1) >> 1;
 351            indexA = QPC + video->FilterOffsetA;
 352            indexB = QPC + video->FilterOffsetB;
 353            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 354            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 355
 356            Alpha  = ALPHA_TABLE[indexA];
 357            Beta = BETA_TABLE[indexB];
 358            clipTable = (int *) CLIP_TAB[indexA];
 359            if (Alpha > 0 && Beta > 0)
 360            {
 361#ifdef USE_PRED_BLOCK
 362                EdgeLoop_Chroma_vertical(SrcU, Strength, Alpha, Beta, clipTable, 12);
 363                EdgeLoop_Chroma_vertical(SrcV, Strength, Alpha, Beta, clipTable, 12);
 364#else
 365                EdgeLoop_Chroma_vertical(SrcU, Strength, Alpha, Beta, clipTable, pitch >> 1);
 366                EdgeLoop_Chroma_vertical(SrcV, Strength, Alpha, Beta, clipTable, pitch >> 1);
 367#endif
 368            }
 369        }
 370
 371    } /* end of: if(filterLeftMbEdgeFlag) */
 372
 373    /* 2.VERTICAL EDGE (no boundary), the edges are all inside a MB */
 374    /* First calculate the necesary parameters all at once, outside the loop */
 375    MbP = MbQ;
 376
 377    indexA = MbQ->QPy + video->FilterOffsetA;
 378    indexB = MbQ->QPy + video->FilterOffsetB;
 379    //  index
 380    indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 381    indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 382
 383    Alpha = ALPHA_TABLE[indexA];
 384    Beta = BETA_TABLE[indexB];
 385    clipTable = (int *)CLIP_TAB[indexA];
 386
 387    /* Save Alpha,  Beta and clipTable for future use, with the obselete variables filterLeftMbEdgeFlag, mbNum amd tmp */
 388    filterLeftMbEdgeFlag = Alpha;
 389    mbNum = Beta;
 390    tmp = (uintptr_t)clipTable;
 391
 392    indexA = MbQ->QPc + video->FilterOffsetA;
 393    indexB = MbQ->QPc + video->FilterOffsetB;
 394    indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 395    indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 396
 397    Alpha_c  = ALPHA_TABLE[indexA];
 398    Beta_c = BETA_TABLE[indexB];
 399    clipTable_c = (int *)CLIP_TAB[indexA];
 400
 401    GetStrength_VerticalEdges(Strength + 4, MbQ); // Strength for 4 blks in 1 stripe, 0 => vertical edge
 402
 403    for (edge = 1; edge < 4; edge++)  // 4 vertical strips of 16 pel
 404    {
 405        //GetStrength_VerticalEdges(video, Strength, MbP, MbQ, 0, edge); // Strength for 4 blks in 1 stripe, 0 => vertical edge
 406        if (*((int*)(Strength + (edge << 2))))   // only if one of the 4 Strength bytes is != 0
 407        {
 408            if (Alpha > 0 && Beta > 0)
 409#ifdef USE_PRED_BLOCK
 410                EdgeLoop_Luma_vertical(SrcY + (edge << 2), Strength + (edge << 2),  Alpha, Beta, clipTable, 20);
 411#else
 412                EdgeLoop_Luma_vertical(SrcY + (edge << 2), Strength + (edge << 2),  Alpha, Beta, clipTable, pitch);
 413#endif
 414
 415            if (!(edge & 1) && Alpha_c > 0 && Beta_c > 0)
 416            {
 417#ifdef USE_PRED_BLOCK
 418                EdgeLoop_Chroma_vertical(SrcU + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
 419                EdgeLoop_Chroma_vertical(SrcV + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
 420#else
 421                EdgeLoop_Chroma_vertical(SrcU + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
 422                EdgeLoop_Chroma_vertical(SrcV + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
 423#endif
 424            }
 425        }
 426
 427    } //end edge
 428
 429
 430
 431    /* 3.HORIZONTAL EDGE + MB BOUNDARY (edge = 0) */
 432    if (filterTopMbEdgeFlag)
 433    {
 434        MbP = MbQ - video->PicWidthInMbs;
 435        //GetStrength(video, Strength, MbP, MbQ, 1, 0); // Strength for 4 blks in 1 stripe, 0 => vertical edge
 436        GetStrength_Edge0(Strength, MbP, MbQ, 1);
 437        str = (void*)Strength; //de-ref type-punned pointer fix
 438        if (*((uint32*)str))    // only if one of the 4 Strength bytes is != 0
 439        {
 440            QP = (MbP->QPy + MbQ->QPy + 1) >> 1; // Average QP of the two blocks;
 441            indexA = QP + video->FilterOffsetA;
 442            indexB = QP + video->FilterOffsetB;
 443            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 444            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 445
 446            Alpha  = ALPHA_TABLE[indexA];
 447            Beta = BETA_TABLE[indexB];
 448            clipTable = (int *)CLIP_TAB[indexA];
 449
 450            if (Alpha > 0 && Beta > 0)
 451            {
 452#ifdef USE_PRED_BLOCK
 453                EdgeLoop_Luma_horizontal(SrcY, Strength,  Alpha, Beta, clipTable, 20);
 454#else
 455                EdgeLoop_Luma_horizontal(SrcY, Strength,  Alpha, Beta, clipTable, pitch);
 456#endif
 457            }
 458
 459            QPC = (MbP->QPc + MbQ->QPc + 1) >> 1;
 460            indexA = QPC + video->FilterOffsetA;
 461            indexB = QPC + video->FilterOffsetB;
 462            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
 463            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
 464
 465            Alpha  = ALPHA_TABLE[indexA];
 466            Beta = BETA_TABLE[indexB];
 467            clipTable = (int *)CLIP_TAB[indexA];
 468            if (Alpha > 0 && Beta > 0)
 469            {
 470#ifdef USE_PRED_BLOCK
 471                EdgeLoop_Chroma_horizontal(SrcU, Strength, Alpha, Beta, clipTable, 12);
 472                EdgeLoop_Chroma_horizontal(SrcV, Strength, Alpha, Beta, clipTable, 12);
 473#else
 474                EdgeLoop_Chroma_horizontal(SrcU, Strength, Alpha, Beta, clipTable, pitch >> 1);
 475                EdgeLoop_Chroma_horizontal(SrcV, Strength, Alpha, Beta, clipTable, pitch >> 1);
 476#endif
 477            }
 478        }
 479
 480    } /* end of: if(filterTopMbEdgeFlag) */
 481
 482
 483    /* 4.HORIZONTAL EDGE (no boundary), the edges are inside a MB */
 484    MbP = MbQ;
 485
 486    /* Recover Alpha,  Beta and clipTable for edge!=0 with the variables filterLeftMbEdgeFlag, mbNum and tmp */
 487    /* Note that Alpha_c, Beta_c and clipTable_c for chroma is already calculated */
 488    Alpha = filterLeftMbEdgeFlag;
 489    Beta = mbNum;
 490    clipTable = (int *)tmp;
 491
 492    GetStrength_HorizontalEdges(Strength + 4, MbQ); // Strength for 4 blks in 1 stripe, 0 => vertical edge
 493
 494    for (edge = 1; edge < 4; edge++)  // 4 horicontal strips of 16 pel
 495    {
 496        //GetStrength(video, Strength, MbP, MbQ, 1, edge); // Strength for 4 blks in 1 stripe   1 => horizontal edge
 497        if (*((int*)(Strength + (edge << 2)))) // only if one of the 4 Strength bytes is != 0
 498        {
 499            if (Alpha > 0 && Beta > 0)
 500            {
 501#ifdef USE_PRED_BLOCK
 502                EdgeLoop_Luma_horizontal(SrcY + (edge << 2)*20, Strength + (edge << 2),  Alpha, Beta, clipTable, 20);
 503#else
 504                EdgeLoop_Luma_horizontal(SrcY + (edge << 2)*pitch, Strength + (edge << 2),  Alpha, Beta, clipTable, pitch);
 505#endif
 506            }
 507
 508            if (!(edge & 1) && Alpha_c > 0 && Beta_c > 0)
 509            {
 510#ifdef USE_PRED_BLOCK
 511                EdgeLoop_Chroma_horizontal(SrcU + (edge << 1)*12, Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
 512                EdgeLoop_Chroma_horizontal(SrcV + (edge << 1)*12, Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
 513#else
 514                EdgeLoop_Chroma_horizontal(SrcU + (edge << 1)*(pitch >> 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
 515                EdgeLoop_Chroma_horizontal(SrcV + (edge << 1)*(pitch >> 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
 516#endif
 517            }
 518        }
 519
 520    } //end edge
 521
 522    return;
 523}
 524
 525/*
 526 *****************************************************************************************************
 527 * \brief   returns a buffer of 4 Strength values for one stripe in a mb (for different Frame types)
 528 *****************************************************************************************************
 529*/
 530
 531void GetStrength_Edge0(uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir)
 532{
 533    int tmp;
 534    int16 *ptrQ, *ptrP;
 535    void* vptr;
 536    uint8 *pStrength;
 537    void* refIdx;
 538
 539    if (MbP->mbMode == AVC_I4 || MbP->mbMode == AVC_I16 ||
 540            MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
 541    {
 542
 543        *((int*)Strength) = ININT_STRENGTH[0];      // Start with Strength=3. or Strength=4 for Mb-edge
 544
 545    }
 546    else // if not intra or SP-frame
 547    {
 548        *((int*)Strength) = 0;
 549
 550        if (dir == 0)  // Vertical Edge 0
 551        {
 552
 553            //1. Check the ref_frame_id
 554            refIdx = (void*) MbQ->RefIdx; //de-ref type-punned pointer fix
 555            ptrQ = (int16*)refIdx;
 556            refIdx = (void*)MbP->RefIdx; //de-ref type-punned pointer fix
 557            ptrP = (int16*)refIdx;
 558            pStrength = Strength;
 559            if (ptrQ[0] != ptrP[1]) pStrength[0] = 1;
 560            if (ptrQ[2] != ptrP[3]) pStrength[2] = 1;
 561            pStrength[1] = pStrength[0];
 562            pStrength[3] = pStrength[2];
 563
 564            //2. Check the non-zero coeff blocks (4x4)
 565            if (MbQ->nz_coeff[0] != 0 || MbP->nz_coeff[3] != 0) pStrength[0] = 2;
 566            if (MbQ->nz_coeff[4] != 0 || MbP->nz_coeff[7] != 0) pStrength[1] = 2;
 567            if (MbQ->nz_coeff[8] != 0 || MbP->nz_coeff[11] != 0) pStrength[2] = 2;
 568            if (MbQ->nz_coeff[12] != 0 || MbP->nz_coeff[15] != 0) pStrength[3] = 2;
 569
 570            //3. Only need to check the mv difference
 571            vptr = (void*)MbQ->mvL0;  // for deref type-punned pointer
 572            ptrQ = (int16*)vptr;
 573            ptrP = (int16*)(MbP->mvL0 + 3); // points to 4x4 block #3 (the 4th column)
 574
 575            // 1st blk
 576            if (*pStrength == 0)
 577            {
 578                // check |mv difference| >= 4
 579                tmp = *ptrQ++ - *ptrP++;
 580                if (tmp < 0) tmp = -tmp;
 581                if (tmp >= 4) *pStrength = 1;
 582
 583                tmp = *ptrQ-- - *ptrP--;
 584                if (tmp < 0) tmp = -tmp;
 585                if (tmp >= 4) *pStrength = 1;
 586            }
 587
 588            pStrength++;
 589            ptrQ += 8;
 590            ptrP += 8;
 591
 592            // 2nd blk
 593            if (*pStrength == 0)
 594            {
 595                // check |mv difference| >= 4
 596                tmp = *ptrQ++ - *ptrP++;
 597                if (tmp < 0) tmp = -tmp;
 598                if (tmp >= 4) *pStrength = 1;
 599
 600                tmp = *ptrQ-- - *ptrP--;
 601                if (tmp < 0) tmp = -tmp;
 602                if (tmp >= 4) *pStrength = 1;
 603            }
 604
 605            pStrength++;
 606            ptrQ += 8;
 607            ptrP += 8;
 608
 609            // 3rd blk
 610            if (*pStrength == 0)
 611            {
 612                // check |mv difference| >= 4
 613                tmp = *ptrQ++ - *ptrP++;
 614                if (tmp < 0) tmp = -tmp;
 615                if (tmp >= 4) *pStrength = 1;
 616
 617                tmp = *ptrQ-- - *ptrP--;
 618                if (tmp < 0) tmp = -tmp;
 619                if (tmp >= 4) *pStrength = 1;
 620            }
 621
 622            pStrength++;
 623            ptrQ += 8;
 624            ptrP += 8;
 625
 626            // 4th blk
 627            if (*pStrength == 0)
 628            {
 629                // check |mv difference| >= 4
 630                tmp = *ptrQ++ - *ptrP++;
 631                if (tmp < 0) tmp = -tmp;
 632                if (tmp >= 4) *pStrength = 1;
 633
 634                tmp = *ptrQ-- - *ptrP--;
 635                if (tmp < 0) tmp = -tmp;
 636                if (tmp >= 4) *pStrength = 1;
 637            }
 638        }
 639        else   // Horizontal Edge 0
 640        {
 641
 642            //1. Check the ref_frame_id
 643            refIdx = (void*)MbQ->RefIdx;  //de-ref type-punned pointer
 644            ptrQ = (int16*)refIdx;
 645            refIdx = (void*)MbP->RefIdx;  //de-ref type-punned pointer
 646            ptrP = (int16*)refIdx;
 647            pStrength = Strength;
 648            if (ptrQ[0] != ptrP[2]) pStrength[0] = 1;
 649            if (ptrQ[1] != ptrP[3]) pStrength[2] = 1;
 650            pStrength[1] = pStrength[0];
 651            pStrength[3] = pStrength[2];
 652
 653            //2. Check the non-zero coeff blocks (4x4)
 654            if (MbQ->nz_coeff[0] != 0 || MbP->nz_coeff[12] != 0) pStrength[0] = 2;
 655            if (MbQ->nz_coeff[1] != 0 || MbP->nz_coeff[13] != 0) pStrength[1] = 2;
 656            if (MbQ->nz_coeff[2] != 0 || MbP->nz_coeff[14] != 0) pStrength[2] = 2;
 657            if (MbQ->nz_coeff[3] != 0 || MbP->nz_coeff[15] != 0) pStrength[3] = 2;
 658
 659            //3. Only need to check the mv difference
 660            vptr = (void*)MbQ->mvL0;
 661            ptrQ = (int16*)vptr;
 662            ptrP = (int16*)(MbP->mvL0 + 12); // points to 4x4 block #12 (the 4th row)
 663
 664            // 1st blk
 665            if (*pStrength == 0)
 666            {
 667                // check |mv difference| >= 4
 668                tmp = *ptrQ++ - *ptrP++;
 669                if (tmp < 0) tmp = -tmp;
 670                if (tmp >= 4) *pStrength = 1;
 671
 672                tmp = *ptrQ-- - *ptrP--;
 673                if (tmp < 0) tmp = -tmp;
 674                if (tmp >= 4) *pStrength = 1;
 675            }
 676
 677            pStrength++;
 678            ptrQ += 2;
 679            ptrP += 2;
 680
 681            // 2nd blk
 682            if (*pStrength  == 0)
 683            {
 684                // check |mv difference| >= 4
 685                tmp = *ptrQ++ - *ptrP++;
 686                if (tmp < 0) tmp = -tmp;
 687                if (tmp >= 4) *pStrength = 1;
 688
 689                tmp = *ptrQ-- - *ptrP--;
 690                if (tmp < 0) tmp = -tmp;
 691                if (tmp >= 4) *pStrength = 1;
 692            }
 693
 694            pStrength++;
 695            ptrQ += 2;
 696            ptrP += 2;
 697
 698            // 3rd blk
 699            if (*pStrength  == 0)
 700            {
 701                // check |mv difference| >= 4
 702                tmp = *ptrQ++ - *ptrP++;
 703                if (tmp < 0) tmp = -tmp;
 704                if (tmp >= 4) *pStrength = 1;
 705
 706                tmp = *ptrQ-- - *ptrP--;
 707                if (tmp < 0) tmp = -tmp;
 708                if (tmp >= 4) *pStrength = 1;
 709            }
 710
 711            pStrength++;
 712            ptrQ += 2;
 713            ptrP += 2;
 714
 715            // 4th blk
 716            if (*pStrength  == 0)
 717            {
 718                // check |mv difference| >= 4
 719                tmp = *ptrQ++ - *ptrP++;
 720                if (tmp < 0) tmp = -tmp;
 721                if (tmp >= 4) *pStrength = 1;
 722
 723                tmp = *ptrQ-- - *ptrP--;
 724                if (tmp < 0) tmp = -tmp;
 725                if (tmp >= 4) *pStrength = 1;
 726            }
 727
 728        } /* end of: else if(dir == 0) */
 729
 730    } /* end of: if( !(MbP->mbMode == AVC_I4 ...) */
 731}
 732
 733
 734void GetStrength_VerticalEdges(uint8 *Strength, AVCMacroblock* MbQ)
 735{
 736    int     idx, tmp;
 737    int16   *ptr, *pmvx, *pmvy;
 738    uint8   *pnz;
 739    uint8   *pStrength, *pStr;
 740    void* refIdx;
 741
 742    if (MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
 743    {
 744        *((int*)Strength)     = ININT_STRENGTH[1];      // Start with Strength=3. or Strength=4 for Mb-edge
 745        *((int*)(Strength + 4)) = ININT_STRENGTH[2];
 746        *((int*)(Strength + 8)) = ININT_STRENGTH[3];
 747    }
 748    else   // Not intra or SP-frame
 749    {
 750
 751        *((int*)Strength)     = 0; // for non-intra MB, strength = 0, 1 or 2.
 752        *((int*)(Strength + 4)) = 0;
 753        *((int*)(Strength + 8)) = 0;
 754
 755        //1. Check the ref_frame_id
 756        refIdx = (void*)MbQ->RefIdx;  //de-ref type-punned pointer fix
 757        ptr = (int16*)refIdx;
 758        pStrength = Strength;
 759        if (ptr[0] != ptr[1]) pStrength[4] = 1;
 760        if (ptr[2] != ptr[3]) pStrength[6] = 1;
 761        pStrength[5] = pStrength[4];
 762        pStrength[7] = pStrength[6];
 763
 764        //2. Check the nz_coeff block and mv difference
 765        pmvx = (int16*)(MbQ->mvL0 + 1); // points to 4x4 block #1,not #0
 766        pmvy = pmvx + 1;
 767        for (idx = 0; idx < 4; idx += 2) // unroll the loop, make 4 iterations to 2
 768        {
 769            // first/third row : 1,2,3 or 9,10,12
 770            // Strength = 2 for a whole row
 771            pnz = MbQ->nz_coeff + (idx << 2);
 772            if (*pnz++ != 0) *pStrength = 2;
 773            if (*pnz++ != 0)
 774            {
 775                *pStrength = 2;
 776                *(pStrength + 4) = 2;
 777            }
 778            if (*pnz++ != 0)
 779            {
 780                *(pStrength + 4) = 2;
 781                *(pStrength + 8) = 2;
 782            }
 783            if (*pnz != 0) *(pStrength + 8) = 2;
 784
 785            // Then Strength = 1
 786            if (*pStrength == 0)
 787            {
 788                //within the same 8x8 block, no need to check the reference id
 789                //only need to check the |mv difference| >= 4
 790                tmp = *pmvx - *(pmvx - 2);
 791                if (tmp < 0) tmp = -tmp;
 792                if (tmp >= 4) *pStrength = 1;
 793
 794                tmp = *pmvy - *(pmvy - 2);
 795                if (tmp < 0) tmp = -tmp;
 796                if (tmp >= 4) *pStrength = 1;
 797            }
 798
 799            pmvx += 2;
 800            pmvy += 2;
 801            pStr = pStrength + 4;
 802
 803            if (*pStr == 0)
 804            {
 805                //check the |mv difference| >= 4
 806                tmp = *pmvx - *(pmvx - 2);
 807                if (tmp < 0) tmp = -tmp;
 808                if (tmp >= 4) *pStr = 1;
 809
 810                tmp = *pmvy - *(pmvy - 2);
 811                if (tmp < 0) tmp = -tmp;
 812                if (tmp >= 4) *pStr = 1;
 813            }
 814
 815            pmvx += 2;
 816            pmvy += 2;
 817            pStr = pStrength + 8;
 818
 819            if (*pStr == 0)
 820            {
 821                //within the same 8x8 block, no need to check the reference id
 822                //only need to check the |mv difference| >= 4
 823                tmp = *pmvx - *(pmvx - 2);
 824                if (tmp < 0) tmp = -tmp;
 825                if (tmp >= 4) *pStr = 1;
 826
 827                tmp = *pmvy - *(pmvy - 2);
 828                if (tmp < 0) tmp = -tmp;
 829                if (tmp >= 4) *pStr = 1;
 830            }
 831
 832            // Second/fourth row: 5,6,7 or 14,15,16
 833            // Strength = 2 for a whole row
 834            pnz = MbQ->nz_coeff + ((idx + 1) << 2);
 835            if (*pnz++ != 0) *(pStrength + 1) = 2;
 836            if (*pnz++ != 0)
 837            {
 838                *(pStrength + 1) = 2;
 839                *(pStrength + 5) = 2;
 840            }
 841            if (*pnz++ != 0)
 842            {
 843                *(pStrength + 5) = 2;
 844                *(pStrength + 9) = 2;
 845            }
 846            if (*pnz != 0) *(pStrength + 9) = 2;
 847
 848            // Then Strength = 1
 849            pmvx += 4;
 850            pmvy += 4;
 851            pStr = pStrength + 1;
 852            if (*pStr == 0)
 853            {
 854                //within the same 8x8 block, no need to check the reference id
 855                //only need to check the |mv difference| >= 4
 856                tmp = *pmvx - *(pmvx - 2);
 857                if (tmp < 0) tmp = -tmp;
 858                if (tmp >= 4) *pStr = 1;
 859
 860                tmp = *pmvy - *(pmvy - 2);
 861                if (tmp < 0) tmp = -tmp;
 862                if (tmp >= 4) *pStr = 1;
 863            }
 864
 865            pmvx += 2;
 866            pmvy += 2;
 867            pStr = pStrength + 5;
 868
 869            if (*pStr == 0)
 870            {
 871                //check the |mv difference| >= 4
 872                tmp = *pmvx - *(pmvx - 2);
 873                if (tmp < 0) tmp = -tmp;
 874                if (tmp >= 4) *pStr = 1;
 875
 876                tmp = *pmvy - *(pmvy - 2);
 877                if (tmp < 0) tmp = -tmp;
 878                if (tmp >= 4) *pStr = 1;
 879            }
 880
 881            pmvx += 2;
 882            pmvy += 2;
 883            pStr = pStrength + 9;
 884
 885            if (*pStr == 0)
 886            {
 887                //within the same 8x8 block, no need to check the reference id
 888                //only need to check the |mv difference| >= 4
 889                tmp = *pmvx - *(pmvx - 2);
 890                if (tmp < 0) tmp = -tmp;
 891                if (tmp >= 4) *pStr = 1;
 892
 893                tmp = *pmvy - *(pmvy - 2);
 894                if (tmp < 0) tmp = -tmp;
 895                if (tmp >= 4) *pStr = 1;
 896            }
 897
 898            // update some variables for the next two rows
 899            pmvx += 4;
 900            pmvy += 4;
 901            pStrength += 2;
 902
 903        } /* end of: for(idx=0; idx<2; idx++) */
 904
 905    } /* end of: else if( MbQ->mbMode == AVC_I4 ...) */
 906}
 907
 908
 909void GetStrength_HorizontalEdges(uint8 Strength[12], AVCMacroblock* MbQ)
 910{
 911    int     idx, tmp;
 912    int16   *ptr, *pmvx, *pmvy;
 913    uint8   *pStrength, *pStr;
 914    void* refIdx;
 915
 916    if (MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
 917    {
 918        *((int*)Strength)     = ININT_STRENGTH[1];      // Start with Strength=3. or Strength=4 for Mb-edge
 919        *((int*)(Strength + 4)) = ININT_STRENGTH[2];
 920        *((int*)(Strength + 8)) = ININT_STRENGTH[3];
 921    }
 922    else   // Not intra or SP-frame
 923    {
 924
 925        *((int*)Strength)     = 0; // for non-intra MB, strength = 0, 1 or 2.
 926        *((int*)(Strength + 4)) = 0; // for non-intra MB, strength = 0, 1 or 2.
 927        *((int*)(Strength + 8)) = 0; // for non-intra MB, strength = 0, 1 or 2.
 928
 929
 930        //1. Check the ref_frame_id
 931        refIdx = (void*) MbQ->RefIdx; // de-ref type-punned fix
 932        ptr = (int16*) refIdx;
 933        pStrength = Strength;
 934        if (ptr[0] != ptr[2]) pStrength[4] = 1;
 935        if (ptr[1] != ptr[3]) pStrength[6] = 1;
 936        pStrength[5] = pStrength[4];
 937        pStrength[7] = pStrength[6];
 938
 939        //2. Check the nz_coeff block and mv difference
 940        pmvx = (int16*)(MbQ->mvL0 + 4); // points to 4x4 block #4,not #0
 941        pmvy = pmvx + 1;
 942        for (idx = 0; idx < 4; idx += 2) // unroll the loop, make 4 iterations to 2
 943        {
 944            // first/third row : 1,2,3 or 9,10,12
 945            // Strength = 2 for a whole row
 946            if (MbQ->nz_coeff[idx] != 0) *pStrength = 2;
 947            if (MbQ->nz_coeff[4+idx] != 0)
 948            {
 949                *pStrength = 2;
 950                *(pStrength + 4) = 2;
 951            }
 952            if (MbQ->nz_coeff[8+idx] != 0)
 953            {
 954                *(pStrength + 4) = 2;
 955                *(pStrength + 8) = 2;
 956            }
 957            if (MbQ->nz_coeff[12+idx] != 0) *(pStrength + 8) = 2;
 958
 959            // Then Strength = 1
 960            if (*pStrength == 0)
 961            {
 962                //within the same 8x8 block, no need to check the reference id
 963                //only need to check the |mv difference| >= 4
 964                tmp = *pmvx - *(pmvx - 8);
 965                if (tmp < 0) tmp = -tmp;
 966                if (tmp >= 4) *pStrength = 1;
 967
 968                tmp = *pmvy - *(pmvy - 8);
 969                if (tmp < 0) tmp = -tmp;
 970                if (tmp >= 4) *pStrength = 1;
 971            }
 972
 973            pmvx += 8;
 974            pmvy += 8;
 975            pStr = pStrength + 4;
 976
 977            if (*pStr == 0)
 978            {
 979                //check the |mv difference| >= 4
 980                tmp = *pmvx - *(pmvx - 8);
 981                if (tmp < 0) tmp = -tmp;
 982                if (tmp >= 4) *pStr = 1;
 983
 984                tmp = *pmvy - *(pmvy - 8);
 985                if (tmp < 0) tmp = -tmp;
 986                if (tmp >= 4) *pStr = 1;
 987            }
 988
 989            pmvx += 8;
 990            pmvy += 8;
 991            pStr = pStrength + 8;
 992
 993            if (*pStr == 0)
 994            {
 995                //within the same 8x8 block, no need to check the reference id
 996                //only need to check the |mv difference| >= 4
 997                tmp = *pmvx - *(pmvx - 8);
 998                if (tmp < 0) tmp = -tmp;
 999                if (tmp >= 4) *pStr = 1;
1000
1001                tmp = *pmvy - *(pmvy - 8);
1002                if (tmp < 0) tmp = -tmp;
1003                if (tmp >= 4) *pStr = 1;
1004            }
1005
1006            // Second/fourth row: 5,6,7 or 14,15,16
1007            // Strength = 2 for a whole row
1008            if (MbQ->nz_coeff[idx+1] != 0) *(pStrength + 1) = 2;
1009            if (MbQ->nz_coeff[4+idx+1] != 0)
1010            {
1011                *(pStrength + 1) = 2;
1012                *(pStrength + 5) = 2;
1013            }
1014            if (MbQ->nz_coeff[8+idx+1] != 0)
1015            {
1016                *(pStrength + 5) = 2;
1017                *(pStrength + 9) = 2;
1018            }
1019            if (MbQ->nz_coeff[12+idx+1] != 0) *(pStrength + 9) = 2;
1020
1021            // Then Strength = 1
1022            pmvx -= 14;
1023            pmvy -= 14; // -14 = -16 + 2
1024            pStr = pStrength + 1;
1025            if (*pStr == 0)
1026            {
1027                //within the same 8x8 block, no need to check the reference id
1028                //only need to check the |mv difference| >= 4
1029                tmp = *pmvx - *(pmvx - 8);
1030                if (tmp < 0) tmp = -tmp;
1031                if (tmp >= 4) *pStr = 1;
1032
1033                tmp = *pmvy - *(pmvy - 8);
1034                if (tmp < 0) tmp = -tmp;
1035                if (tmp >= 4) *pStr = 1;
1036            }
1037
1038            pmvx += 8;
1039            pmvy += 8;
1040            pStr = pStrength + 5;
1041
1042            if (*pStr == 0)
1043            {
1044                //check the |mv difference| >= 4
1045                tmp = *pmvx - *(pmvx - 8);
1046                if (tmp < 0) tmp = -tmp;
1047                if (tmp >= 4) *pStr = 1;
1048
1049                tmp = *pmvy - *(pmvy - 8);
1050                if (tmp < 0) tmp = -tmp;
1051                if (tmp >= 4) *pStr = 1;
1052            }
1053
1054            pmvx += 8;
1055            pmvy += 8;
1056            pStr = pStrength + 9;
1057
1058            if (*pStr == 0)
1059            {
1060                //within the same 8x8 block, no need to check the reference id
1061                //only need to check the |mv difference| >= 4
1062                tmp = *pmvx - *(pmvx - 8);
1063                if (tmp < 0) tmp = -tmp;
1064                if (tmp >= 4) *pStr = 1;
1065
1066                tmp = *pmvy - *(pmvy - 8);
1067                if (tmp < 0) tmp = -tmp;
1068                if (tmp >= 4) *pStr = 1;
1069            }
1070
1071            // update some variables for the next two rows
1072            pmvx -= 14;
1073            pmvy -= 14; // -14 = -16 + 2
1074            pStrength += 2;
1075
1076        } /* end of: for(idx=0; idx<2; idx++) */
1077
1078    } /* end of: else if( MbQ->mbMode == AVC_I4 ...) */
1079}
1080
1081/*
1082 *****************************************************************************************
1083 * \brief  Filters one edge of 16 (luma) or 8 (chroma) pel
1084 *****************************************************************************************
1085*/
1086
1087void EdgeLoop_Luma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
1088{
1089    int  pel, ap = 0, aq = 0, Strng;
1090    int  C0, c0, dif, AbsDelta, tmp, tmp1;
1091    int  L2 = 0, L1, L0, R0, R1, R2 = 0, RL0;
1092
1093
1094    if (Strength[0] == 4)  /* INTRA strong filtering */
1095    {
1096        for (pel = 0; pel < 16; pel++)
1097        {
1098            R0  = SrcPtr[0];
1099            R1  = SrcPtr[pitch];
1100            L0  = SrcPtr[-pitch];
1101            L1  = SrcPtr[-(pitch<<1)];
1102
1103            // |R0 - R1| < Beta
1104            tmp1 = R0 - R1;
1105            if (tmp1 < 0) tmp1 = -tmp1;
1106            tmp = (tmp1 - Beta);
1107
1108            //|L0 - L1| < Beta
1109            tmp1 = L0 - L1;
1110            if (tmp1 < 0) tmp1 = -tmp1;
1111            tmp &= (tmp1 - Beta);
1112
1113            //|R0 - L0| < Alpha
1114            AbsDelta = R0 - L0;
1115            if (AbsDelta < 0) AbsDelta = -AbsDelta;
1116            tmp &= (AbsDelta - Alpha);
1117
1118            if (tmp < 0)
1119            {
1120                AbsDelta -= ((Alpha >> 2) + 2);
1121                R2 = SrcPtr[pitch<<1]; //inc2
1122                L2 = SrcPtr[-(pitch+(pitch<<1))]; // -inc3
1123
1124                // |R0 - R2| < Beta && |R0 - L0| < (Alpha/4 + 2)
1125                tmp = R0 - R2;
1126                if (tmp < 0) tmp = -tmp;
1127                aq = AbsDelta & (tmp - Beta);
1128
1129                // |L0 - L2| < Beta && |R0 - L0| < (Alpha/4 + 2)
1130                tmp = L0 - L2;
1131                if (tmp < 0) tmp = -tmp;
1132                ap = AbsDelta & (tmp - Beta);
1133
1134                if (aq < 0)
1135                {
1136                    tmp = R1 + R0 + L0;
1137                    SrcPtr[0] = (L1 + (tmp << 1) +  R2 + 4) >> 3;
1138                    tmp += R2;
1139                    SrcPtr[pitch]  = (tmp + 2) >> 2;
1140                    SrcPtr[pitch<<1] = (((SrcPtr[(pitch+(pitch<<1))] + R2) << 1) + tmp + 4) >> 3;
1141                }
1142                else
1143                    SrcPtr[0] = ((R1 << 1) + R0 + L1 + 2) >> 2;
1144
1145                if (ap < 0)
1146                {
1147                    tmp = L1 + R0 + L0;
1148                    SrcPtr[-pitch]  = (R1 + (tmp << 1) +  L2 + 4) >> 3;
1149                    tmp += L2;
1150                    SrcPtr[-(pitch<<1)] = (tmp + 2) >> 2;
1151                    SrcPtr[-(pitch+(pitch<<1))] = (((SrcPtr[-(pitch<<2)] + L2) << 1) + tmp + 4) >> 3;
1152                }
1153                else
1154                    SrcPtr[-pitch] = ((L1 << 1) + L0 + R1 + 2) >> 2;
1155
1156            } /* if(tmp < 0) */
1157
1158            SrcPtr ++; // Increment to next set of pixel
1159
1160        } /* end of: for(pel=0; pel<16; pel++) */
1161
1162    } /* if(Strength[0] == 4) */
1163
1164    else   /* Normal filtering */
1165    {
1166        for (pel = 0; pel < 16; pel++)
1167        {
1168            Strng = Strength[pel >> 2];
1169            if (Strng)
1170            {
1171                R0  = SrcPtr[0];
1172                R1  = SrcPtr[pitch];
1173                L0  = SrcPtr[-pitch];
1174                L1  = SrcPtr[-(pitch<<1)]; // inc2
1175
1176                //|R0 - L0| < Alpha
1177                tmp1 = R0 - L0;
1178                if (tmp1 < 0) tmp1 = -tmp1;
1179                tmp = (tmp1 - Alpha);
1180
1181                // |R0 - R1| < Beta
1182                tmp1 = R0 - R1;
1183                if (tmp1 < 0) tmp1 = -tmp1;
1184                tmp &= (tmp1 - Beta);
1185
1186                //|L0 - L1| < Beta
1187                tmp1 = L0 - L1;
1188                if (tmp1 < 0) tmp1 = -tmp1;
1189                tmp &= (tmp1 - Beta);
1190
1191                if (tmp < 0)
1192                {
1193                    R2 = SrcPtr[pitch<<1]; //inc2
1194                    L2 = SrcPtr[-(pitch+(pitch<<1))]; // -inc3
1195
1196                    // |R0 - R2| < Beta
1197                    tmp = R0 - R2;
1198                    if (tmp < 0) tmp = -tmp;
1199                    aq = tmp - Beta;
1200
1201                    // |L0 - L2| < Beta
1202                    tmp = L0 - L2;
1203                    if (tmp < 0) tmp = -tmp;
1204                    ap = tmp - Beta;
1205
1206
1207                    c0 = C0 = clipTable[Strng];
1208                    if (ap < 0) c0++;
1209                    if (aq < 0) c0++;
1210
1211                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
1212                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
1213                    tmp = dif + c0;
1214                    if ((uint)tmp > (uint)c0 << 1)
1215                    {
1216                        tmp = ~(tmp >> 31);
1217                        dif = (tmp & (c0 << 1)) - c0;
1218                    }
1219
1220                    //SrcPtr[0]    = (uint8)IClip(0, 255, R0 - dif);
1221                    //SrcPtr[-inc] = (uint8)IClip(0, 255, L0 + dif);
1222                    RL0 = R0 + L0;
1223                    R0 -= dif;
1224                    L0 += dif;
1225                    if ((uint)R0 > 255)
1226                    {
1227                        tmp = ~(R0 >> 31);
1228                        R0 = tmp & 255;
1229                    }
1230                    if ((uint)L0 > 255)
1231                    {
1232                        tmp = ~(L0 >> 31);
1233                        L0 = tmp & 255;
1234                    }
1235                    SrcPtr[-pitch] = L0;
1236                    SrcPtr[0] = R0;
1237
1238                    if (C0 != 0) /* Multiple zeros in the clip tables */
1239                    {
1240                        if (aq < 0)  // SrcPtr[inc]   += IClip(-C0, C0,(R2 + ((RL0 + 1) >> 1) - (R1<<1)) >> 1);
1241                        {
1242                            R2 = (R2 + ((RL0 + 1) >> 1) - (R1 << 1)) >> 1;
1243                            tmp = R2 + C0;
1244                            if ((uint)tmp > (uint)C0 << 1)
1245                            {
1246                                tmp = ~(tmp >> 31);
1247                                R2 = (tmp & (C0 << 1)) - C0;
1248                            }
1249                            SrcPtr[pitch] += R2;
1250                        }
1251
1252                        if (ap < 0)  //SrcPtr[-inc2] += IClip(-C0, C0,(L2 + ((RL0 + 1) >> 1) - (L1<<1)) >> 1);
1253                        {
1254                            L2 = (L2 + ((RL0 + 1) >> 1) - (L1 << 1)) >> 1;
1255                            tmp = L2 + C0;
1256                            if ((uint)tmp > (uint)C0 << 1)
1257                            {
1258                                tmp = ~(tmp >> 31);
1259                                L2 = (tmp & (C0 << 1)) - C0;
1260                            }
1261                            SrcPtr[-(pitch<<1)] += L2;
1262                        }
1263                    }
1264
1265                } /* if(tmp < 0) */
1266
1267            } /* end of:  if((Strng = Strength[pel >> 2])) */
1268
1269            SrcPtr ++; // Increment to next set of pixel
1270
1271        } /* for(pel=0; pel<16; pel++) */
1272
1273    } /* else if(Strength[0] == 4) */
1274}
1275
1276void EdgeLoop_Luma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
1277{
1278    int  pel, ap = 1, aq = 1;
1279    int  C0, c0, dif, AbsDelta, Strng, tmp, tmp1;
1280    int  L2 = 0, L1, L0, R0, R1, R2 = 0;
1281    uint8 *ptr, *ptr1;
1282    register uint R_in, L_in;
1283    uint R_out, L_out;
1284
1285
1286    if (Strength[0] == 4)  /* INTRA strong filtering */
1287    {
1288
1289        for (pel = 0; pel < 16; pel++)
1290        {
1291
1292            // Read 8 pels
1293            R_in = *((uint *)SrcPtr);       // R_in = {R3, R2, R1, R0}
1294            L_in = *((uint *)(SrcPtr - 4)); // L_in = {L0, L1, L2, L3}
1295            R1   = (R_in >> 8) & 0xff;
1296            R0   = R_in & 0xff;
1297            L0   = L_in >> 24;
1298            L1   = (L_in >> 16) & 0xff;
1299
1300            // |R0 - R1| < Beta
1301            tmp1 = (R_in & 0xff) - R1;
1302            if (tmp1 < 0) tmp1 = -tmp1;
1303            tmp = (tmp1 - Beta);
1304
1305
1306            //|L0 - L1| < Beta
1307            tmp1 = (L_in >> 24) - L1;
1308            if (tmp1 < 0) tmp1 = -tmp1;
1309            tmp &= (tmp1 - Beta);
1310
1311            //|R0 - L0| < Alpha
1312            AbsDelta = (R_in & 0xff) - (L_in >> 24);
1313            if (AbsDelta < 0) AbsDelta = -AbsDelta;
1314            tmp &= (AbsDelta - Alpha);
1315
1316            if (tmp < 0)
1317            {
1318                AbsDelta -= ((Alpha >> 2) + 2);
1319                R2   = (R_in >> 16) & 0xff;
1320                L2   = (L_in >> 8) & 0xff;
1321
1322                // |R0 - R2| < Beta && |R0 - L0| < (Alpha/4 + 2)
1323                tmp1 = (R_in & 0xff) - R2;
1324                if (tmp1 < 0) tmp1 = -tmp1;
1325                aq = AbsDelta & (tmp1 - Beta);
1326
1327                // |L0 - L2| < Beta && |R0 - L0| < (Alpha/4 + 2)
1328                tmp1 = (L_in >> 24) - L2;
1329                if (tmp1 < 0) tmp1 = -tmp1;
1330                ap = AbsDelta & (tmp1 - Beta);
1331
1332
1333                ptr = SrcPtr;
1334                if (aq < 0)
1335                {
1336                    R_out = (R_in >> 24) << 24; // Keep R3 at the fourth byte
1337
1338                    tmp  = R0 + L0 + R1;
1339                    R_out |= (((tmp << 1) +  L1 + R2 + 4) >> 3);
1340                    tmp += R2;
1341                    R_out |= (((tmp + 2) >> 2) << 8);
1342                    tmp1 = ((R_in >> 24) + R2) << 1;
1343                    R_out |= (((tmp1 + tmp + 4) >> 3) << 16);
1344
1345                    *((uint *)SrcPtr) = R_out;
1346                }
1347                else
1348                    *ptr = ((R1 << 1) + R0 + L1 + 2) >> 2;
1349
1350
1351                if (ap < 0)
1352                {
1353                    L_out = (L_in << 24) >> 24; // Keep L3 at the first byte
1354
1355                    tmp  = R0 + L0 + L1;
1356                    L_out |= ((((tmp << 1) + R1 + L2 + 4) >> 3) << 24);
1357                    tmp += L2;
1358                    L_out |= (((tmp + 2) >> 2) << 16);
1359                    tmp1 = ((L_in & 0xff) + L2) << 1;
1360                    L_out |= (((tmp1 + tmp + 4) >> 3) << 8);
1361
1362                    *((uint *)(SrcPtr - 4)) = L_out;
1363                }
1364                else
1365                    *(--ptr) = ((L1 << 1) + L0 + R1 + 2) >> 2;
1366
1367            } /* if(tmp < 0) */
1368
1369            SrcPtr += pitch;    // Increment to next set of pixel
1370
1371        } /* end of: for(pel=0; pel<16; pel++) */
1372
1373    } /* if(Strength[0] == 4) */
1374
1375    else   /* Normal filtering */
1376    {
1377
1378        for (pel = 0; pel < 16; pel++)
1379        {
1380            Strng = Strength[pel >> 2];
1381            if (Strng)
1382            {
1383                // Read 8 pels
1384                R_in = *((uint *)SrcPtr);       // R_in = {R3, R2, R1, R0}
1385                L_in = *((uint *)(SrcPtr - 4)); // L_in = {L0, L1, L2, L3}
1386                R1   = (R_in >> 8) & 0xff;
1387                R0   = R_in & 0xff;
1388                L0   = L_in >> 24;
1389                L1   = (L_in >> 16) & 0xff;
1390
1391                //|R0 - L0| < Alpha
1392                tmp = R0 - L0;
1393                if (tmp < 0) tmp = -tmp;
1394                tmp -= Alpha;
1395
1396                // |R0 - R1| < Beta
1397                tmp1 = R0 - R1;
1398                if (tmp1 < 0) tmp1 = -tmp1;
1399                tmp &= (tmp1 - Beta);
1400
1401                //|L0 - L1| < Beta
1402                tmp1 = L0 - L1;
1403                if (tmp1 < 0) tmp1 = -tmp1;
1404                tmp &= (tmp1 - Beta);
1405
1406                if (tmp < 0)
1407                {
1408                    L2 = SrcPtr[-3];
1409                    R2 = SrcPtr[2];
1410
1411                    // |R0 - R2| < Beta
1412                    tmp = R0 - R2;
1413                    if (tmp < 0) tmp = -tmp;
1414                    aq = tmp - Beta;
1415
1416                    // |L0 - L2| < Beta
1417                    tmp = L0 - L2;
1418                    if (tmp < 0) tmp = -tmp;
1419                    ap = tmp - Beta;
1420
1421
1422                    c0 = C0 = clipTable[Strng];
1423                    if (ap < 0) c0++;
1424                    if (aq < 0) c0++;
1425
1426                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
1427                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
1428                    tmp = dif + c0;
1429                    if ((uint)tmp > (uint)c0 << 1)
1430                    {
1431                        tmp = ~(tmp >> 31);
1432                        dif = (tmp & (c0 << 1)) - c0;
1433                    }
1434
1435                    ptr = SrcPtr;
1436                   

Large files files are truncated, but you can click here to view the full file