SSE图像算法优化系列二十四: 基于形态学的图像后期抗锯齿算法--MLAA优化研究。

//-------------------------------------------------------------------------------------------------------------------
// This task analyzes the color buffer for discontinuities between pixels to set the edge flags in the work buffer.
//-------------------------------------------------------------------------------------------------------------------
void MLAAFindDiscontinuitiesTask(VOID* pvInfo, INT, UINT uTaskId, UINT)
{
    MLAAData* pMLAATaskData = static_cast<MLAAData*>(pvInfo);
    UINT*     ColorBuffer   = pMLAATaskData->pColorBuffer;
    UINT      BufferWidth   = pMLAATaskData->uWidth;
    UINT      BufferHeight  = pMLAATaskData->uHeight;
    UINT      BufferPitch   = pMLAATaskData->uRowPitch;            // in pixels, not bytes.
    UINT      TaskFirstRow  = uTaskId * RowsOrColsPerTask;
    UINT      TaskLastRow   = TaskFirstRow + RowsOrColsPerTask;

    for(UINT iRow = TaskFirstRow; iRow < TaskLastRow; iRow += 4)
    {
        UINT BlockFirstRowOffset = iRow * BufferPitch;
        for(UINT iCol = 0; iCol < BufferWidth; iCol += 4)
        {
            __m128i *PixelData  = reinterpret_cast<__m128i*>(ColorBuffer + BlockFirstRowOffset + iCol);
            // BufferPitch is in pixels i.e. 32-bit units, and PixelData points to a 128-bit data type...
            UINT BufferPitch128 = BufferPitch/4;    

            // Load pixel block from color buffer. vPixels0 contains the 4 pixels indexed by iRow and iCol, 
            // vPixels1, the 4 pixels just below the pixels in vPixels0, and so on and so forth.
            __m128i vPixels0 = _mm_load_si128(PixelData);
            __m128i vPixels1 = _mm_load_si128(PixelData +   BufferPitch128);
            __m128i vPixels2 = _mm_load_si128(PixelData + 2*BufferPitch128);
            __m128i vPixels3 = _mm_load_si128(PixelData + 3*BufferPitch128);
            __m128i vPixels4 = (iRow == BufferHeight - 4) ? 
                vPixels3 // For the last block (vertically), add a virtual row by duplicating the last real block row.
                : _mm_load_si128(PixelData + BufferPitch);

            // zero alpha, we are using it to store discontinuity flags.
            __m128i vZeroAlpha = _mm_set1_epi32(0x00FFFFFF);
            vPixels0 = _mm_and_si128(vPixels0, vZeroAlpha);
            vPixels1 = _mm_and_si128(vPixels1, vZeroAlpha);
            vPixels2 = _mm_and_si128(vPixels2, vZeroAlpha);
            vPixels3 = _mm_and_si128(vPixels3, vZeroAlpha);

            // Check for horizontal pixel discontinuities, one row of 4 pixels checked per call.
            // (we compare a row of 4 pixels with its bottom neighbor)
            ComparePixelsSSE(vPixels0, vPixels1, EdgeFlagH);
            ComparePixelsSSE(vPixels1, vPixels2, EdgeFlagH);
            ComparePixelsSSE(vPixels2, vPixels3, EdgeFlagH);
            ComparePixelsSSE(vPixels3, vPixels4, EdgeFlagH);

            // Transpose pixel block so we can use ComparePixelsSSE to check for vertical discontinuities.
            _MM_TRANSPOSE4_PS(
                reinterpret_cast<__m128&>(vPixels0), 
                reinterpret_cast<__m128&>(vPixels1), 
                reinterpret_cast<__m128&>(vPixels2), 
                reinterpret_cast<__m128&>(vPixels3) );
                    
                vPixels4 = (iCol == BufferWidth - 4) ? 
                    vPixels3 // For the last block (horizontally), add a virtual column by duplicating the last real column.
                :   _mm_setr_epi32(
                        * reinterpret_cast<UINT*>(PixelData + 1),
                        * reinterpret_cast<UINT*>(PixelData +   BufferPitch128 + 1),
                        * reinterpret_cast<UINT*>(PixelData + 2*BufferPitch128 + 1),
                        * reinterpret_cast<UINT*>(PixelData + 3*BufferPitch128 + 1) );
            
            // Now vPixels0..4 contains the block of pixel data in column order, e.g. 
            // vPixels0 now stores the leftmost column of 4 pixels, vPixels1 the 2nd leftmost one, etc.
            // Now check for vertical pixel discontinuities, one column of 4 pixels checked per call.
            // (we compare a column of 4 pixels with its neighbor on the right)
            ComparePixelsSSE(vPixels0, vPixels1, EdgeFlagV);
            ComparePixelsSSE(vPixels1, vPixels2, EdgeFlagV);
            ComparePixelsSSE(vPixels2, vPixels3, EdgeFlagV);
            ComparePixelsSSE(vPixels3, vPixels4, EdgeFlagV);

            // Transpose back and store in color buffer the pixel data with added discontinuities flags.
            _MM_TRANSPOSE4_PS(
            reinterpret_cast<__m128&>(vPixels0), 
            reinterpret_cast<__m128&>(vPixels1), 
            reinterpret_cast<__m128&>(vPixels2), 
            reinterpret_cast<__m128&>(vPixels3) );

            _mm_store_si128(PixelData,                    vPixels0);
            _mm_store_si128(PixelData +   BufferPitch128, vPixels1);
            _mm_store_si128(PixelData + 2*BufferPitch128, vPixels2);
            _mm_store_si128(PixelData + 3*BufferPitch128, vPixels3);
        }
    }
}

//--------------------------------------------------------------------------------------------------------------
// Given a row of 4 pixels, check for color discontinuities between a pixel and its neighbor.
// SSE implementation, so we process the 4 consecutive pixels at a time.
// If a discontinuity is detected, the flag passed as 3rd arg. is set in the alpha component of the pixel.
// vPixels0 is the vector of 4 pixels to be flagged if discontinuities are detected.
// vPixels1 is the vector of 4 neighbor pixels.
//--------------------------------------------------------------------------------------------------------------
inline void ComparePixelsSSE(__m128i& vPixels0, __m128i vPixels1, const INT EdgeFlag)
{
    // Each byte of vDiff is the absolute difference between a pixel‘s color channel value, and the one from its neighbor.
    __m128i vDiff = _mm_sub_epi8(_mm_max_epu8(vPixels0, vPixels1), _mm_min_epu8(vPixels0, vPixels1));
    // We are only interested if the difference is greater than 16, and not interested in alpha differences.
    const INT Threshold = 0x00F0F0F0;
    __m128i vThresholdMask = _mm_set1_epi32(Threshold);
    vDiff = _mm_and_si128(vDiff, vThresholdMask);
    // Each of the four lanes of the selector is 0 if no discontinuity detected RGB, 0xFFFFFFFF else.
    __m128i vSelector = _mm_cmpeq_epi32(vDiff, _mm_setzero_si128());
    __m128i vEdgeFlag = _mm_set1_epi32(EdgeFlag);
    vEdgeFlag = _mm_andnot_si128(vSelector, vEdgeFlag);
    // vEdgeFlag now contains EdgeFlag for the pixels where a discontinuity was detected, 0 otherwise.
    vPixels0 = _mm_or_si128(vPixels0, vEdgeFlag);
}

//    返回8位字节数数据的差的绝对值
inline __m128i _mm_absdiff_epu8(__m128i a, __m128i b)
{
    return _mm_or_si128(_mm_subs_epu8(a, b), _mm_subs_epu8(b, a));
}

//-----------------------------------------------------------------------------------------------------------------------------------------
// Given a range of pixels offsets [OffsetCurrentPixel, OffsetEndRow], walk this range to find a discontinuity line.
// We call a "separation line" or "discontinuity line" a sequence of consecutive pixels that all have the same edge flag set.
// The 3 return values are: the length of the separation line, and the offsets in the buffer of the first and last pixel of the line.
//-----------------------------------------------------------------------------------------------------------------------------------------
inline UINT FindSeparationLine(int& OutOffsetLineStart, int& OutOffsetLineEnd, UINT* WorkBuffer, UINT OffsetCurrentPixel, UINT OffsetEndRow, const INT EdgeFlag)
{
    if (OffsetCurrentPixel >= OffsetEndRow)
    {    // We are done scanning this row/column; no separation line left to find.
        return 0;
    }
    // Find first extremity of the line...            找寻线的端头
    OutOffsetLineStart = -1;
    int Shift = (EdgeFlag == EdgeFlagV) ? 1 : 0;
    for (;;)
    {    
        __m128i PixelFlags = _mm_loadu_si128((__m128i*)(WorkBuffer + OffsetCurrentPixel));
        PixelFlags = _mm_slli_epi32(PixelFlags, Shift);
        // Creates a 4-bit mask from the edge flag of each of the 4 pixels
        int HFlags = _mm_movemask_ps(_mm_castsi128_ps(PixelFlags));
        if (HFlags)
        {
            unsigned long Index;
            _BitScanForward(&Index, HFlags);
            OffsetCurrentPixel += Index;
            OutOffsetLineStart = OffsetCurrentPixel;
            break;
        }
        OffsetCurrentPixel += 4;    // None of the pixels had its flag set so we can jump ahead 4 pixels...
        if (OffsetCurrentPixel >= OffsetEndRow)
        {    // Done scanning this row/column, without finding a separation line.
            OutOffsetLineStart = OutOffsetLineEnd = OffsetEndRow - 1;
            return 0;
        }
    }
FindEndOffset:
    // Now look for the second extremity of the line.
    // We could use a SSE-based optimization as the one above, but it remains to be seen if it would help significantly the performance.
    // (discontinuity lines tend to be short)
    UINT LineLength = 1;
    ++OffsetCurrentPixel;
    while ((OffsetCurrentPixel <= OffsetEndRow) && ((WorkBuffer[OffsetCurrentPixel] & EdgeFlag) != 0))
    {
        ++LineLength;
        ++OffsetCurrentPixel;
    }
    OutOffsetLineEnd = OffsetCurrentPixel - 1;
    return LineLength;
}

inline void MixColors(UINT* ColorBuffer, UINT OffsetDst, float Weight1, UINT Offset1, float Weight2, UINT Offset2)
{
    // Load pixels and convert the bytes to dwords
    __m128i Col1i = _mm_cvtsi32_si128(ColorBuffer[Offset1]);
    __m128i Col2i = _mm_cvtsi32_si128(ColorBuffer[Offset2]);
    __m128i Zero = _mm_setzero_si128();
    Col1i = _mm_unpacklo_epi16(_mm_unpacklo_epi8(Col1i, Zero), Zero);
    Col2i = _mm_unpacklo_epi16(_mm_unpacklo_epi8(Col2i, Zero), Zero);
    // Convert to floats so the pixels can be multplied with the weights
    __m128 Col1f = _mm_cvtepi32_ps(Col1i);
    __m128 Col2f = _mm_cvtepi32_ps(Col2i);
    Col1f = _mm_mul_ps(Col1f, _mm_set1_ps(Weight1));
    Col2f = _mm_mul_ps(Col2f, _mm_set1_ps(Weight2));
    Col1f = _mm_add_ps(Col1f, Col2f);
    // Go back to byte from float
    __m128i Coli = _mm_cvttps_epi32(Col1f);
    Coli = _mm_packs_epi32(Coli, Coli);
    Coli = _mm_packus_epi16(Coli, Coli);
    // Store the weighted pixel
    ColorBuffer[OffsetDst] = (ColorBuffer[OffsetDst] & 0xFF000000) | (_mm_cvtsi128_si32(Coli) & 0x00FFFFFF);
}

    ComputeUpperBounds(ui0, ui1, uh0, uh1,
        ColorBuffer,
        OffsetLineStart - 1, OffsetLineEnd, SeparationLineLength, StepToPreviousRow, BufferPitch, BufferPitch * Height, EdgeFlag);

inline float ComputeHc(UINT* WorkBuffer, UINT PrimaryEdgeLength, UINT OffsetC1, UINT OffsetC2, UINT OffsetD2, UINT OffsetD3)
{
    int C2 = SumColor(WorkBuffer[OffsetC2]);
    int C1 = SumColor(WorkBuffer[OffsetC1]);
    int D3 = SumColor(WorkBuffer[OffsetD3]);
    int D2 = SumColor(WorkBuffer[OffsetD2]);

    int D3D2Diff = D3 - D2;
    int C1C2Diff = C1 - C2;
    int D2C2Diff = D2 - C2;

    return float(PrimaryEdgeLength * D2C2Diff + C1C2Diff + D3D2Diff) / (PrimaryEdgeLength * (C1C2Diff - D3D2Diff) + C1C2Diff + D3D2Diff);
}

To state the requirements for smooth transition between two shapes, we compute the same blended color twice, using parameters of 
each shape: 

if (BelowOffset + StepToNextRow < BufferSizeInPixels)
{
    OutH1 = ComputeHc(WorkBuffer, LineLength - NSteps, BelowOffset + StepToNextRow + 1, BelowOffset + 1, BelowOffset, CurrentOffset);
}
else
{    // We are too close to the  end of the buffer to be able to do the ComputeHc calculation, so use default hc value of 0.5
    OutH1 = 0.5;
}
if ((OutH1 > 0) && (OutH1 < 1))
{    // If the computed value of hc is in the acceptable range, then we‘re done else keep walking
    OutS1 = CurrentOffset;
    break;
}

int BlockSize = 16, Block = (Width - 1) / BlockSize;        //    垂直和水平方向比较同步进行，考虑到垂直方向比较时最后一列不能参与
__m128i T = _mm_set1_epi8(Threshold);
for (int Y = 0; Y < Height - 1; Y++)                        //    水平比较时最后一行像素不能参与
{
    unsigned char *LinePS = Src + Y * Stride;
    unsigned char *LinePN = LinePS + Stride;
    unsigned char *LinePM = Mask + Y * Width;
    for (int X = 0; X < Block * BlockSize; X += BlockSize)
    {
        __m128i SrcH1 = _mm_loadu_si128((__m128i *)(LinePS + X));
        //__m128i SrcH2 = _mm_loadu_si128((__m128i *)(LinePS + X + 1));
        __m128i SrcH2 = _mm_insert_epi8(_mm_srli_si128(SrcH1, 1), LinePS[X + 16], 15);        //    似乎速度有没啥区别
        __m128i SrcV1 = _mm_loadu_si128((__m128i *)(LinePN + X));
        __m128i AbsDiffH = _mm_absdiff_epu8(SrcH1, SrcV1);    //    水平方向比较，abs(Bottom - Current)，似乎和常人了解的水平方向不一致
        __m128i AbsDiffV = _mm_absdiff_epu8(SrcH1, SrcH2);;    //    垂直方向比较，abs(Right - Current)
        __m128i FlagH = _mm_and_si128(_mm_set1_epi8(EdgeFlagH), _mm_cmpge_epu8(AbsDiffH, T));        //    设置水平方向的标志位
        __m128i FlagV = _mm_and_si128(_mm_set1_epi8(EdgeFlagV), _mm_cmpge_epu8(AbsDiffV, T));        //    设置垂直方向的标志位
        _mm_storeu_si128((__m128i *)(LinePM + X), _mm_or_si128(FlagH, FlagV));                        //    设置总的标志位
    }
　　//　　...............
}

int BlockSize = 4, Block = (Width - 1) / BlockSize;        //    垂直和水平方向比较同步进行，考虑到垂直方向比较时最后一列不能参与
__m128i T = _mm_set1_epi8(Threshold);
for (int Y = 0; Y < Height - 1; Y++)                        //    水平比较时最后一行像素不能参与
{
    unsigned char *LinePS = Src + Y * Stride;
    unsigned char *LinePN = LinePS + Stride;
    unsigned char *LinePM = Mask + Y * Width;
    for (int X = 0; X < Block * BlockSize; X += BlockSize)
    {
        __m128i SrcH1 = _mm_loadu_si128((__m128i *)(LinePS + X * 4));
        __m128i SrcH2 = _mm_loadu_si128((__m128i *)(LinePS + X * 4 + 4));
        __m128i SrcV1 = _mm_loadu_si128((__m128i *)(LinePN + X * 4));
        __m128i AbsDiffH = _mm_absdiff_epu8(SrcH1, SrcV1);        //    水平方向比较，abs(Bottom - Current)，似乎和常人了解的水平方向不一致
        __m128i AbsDiffV = _mm_absdiff_epu8(SrcH1, SrcH2);        //    垂直方向比较，abs(Right - Current)
        __m128i FlagH = _mm_andnot_si128(_mm_cmpeq_epi32(_mm_cmpge_epu8(AbsDiffH, T), _mm_setzero_si128()), _mm_set1_epi32(EdgeFlagH));        //    设置水平方向的标志位,注意_mm_andnot_si128是对参数的顺序敏感的,(~a) & b
        __m128i FlagV = _mm_andnot_si128(_mm_cmpeq_epi32(_mm_cmpge_epu8(AbsDiffV, T), _mm_setzero_si128()), _mm_set1_epi32(EdgeFlagV));        //    设置垂直方向的标志位
        
        _mm_storesi128_4char(LinePM + X, _mm_or_si128(FlagH, FlagV));//    设置总的标志位    
    }
//　　..........
}

__m128i PixelFlags = _mm_loadu_si128((__m128i*)(Mask + Y));                                 //    合理加载数据， 不能超出范围
int HFlags = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_and_si128(PixelFlags, Flag), Flag));      //    _mm_movemask_epi8提取每个字节的最高位来组成一个16位数    
if (HFlags != 0)                                                                            //    说明在这16个元素里有部分标记是符合条件的
{
    unsigned long Index;
    _BitScanForward(&Index, HFlags);                                                        //    找到第一个位为1值得索引（从低到高位寻找），intel的bsf指令
    OutOffsetLineStart = Y + Index;
    goto FindEndOffset;                                                                     //    寻找结束位置
}