winamp/Src/libvpShared/corelibs/cdxv/pp/Win32/rowdiffscan.c

/****************************************************************************
*
*   Module Title :     RowDiffScan.c
*
*   Description  :     Pre-processor row difference Scan
*
*    AUTHOR      :     Paul Wilkins
*
*****************************************************************************
*   Revision History
*
*   1.00 JBB 22 AUG 00	Configuration baseline
*
*****************************************************************************
*/						

/****************************************************************************
*  Header Frames
*****************************************************************************
*/

#define STRICT              /* Strict type checking. */

#include "type_aliases.h"
#include "preproc.h"


/****************************************************************************
*  Module constants.
*****************************************************************************

/****************************************************************************
 * 
 *  ROUTINE       :     RowDiffScan
 *
 *  INPUTS        :     UINT8  * YuvPtr1, YuvPtr2 
 *								 Pointers into current and previous frame
 *                      BOOL     EdgeRow
 *                               Is this row an edge row.
 *
 *  OUTPUTS       :		UINT16 * YUVDiffsPtr
 *								 Differnece map
 *                      UINT8  * bits_map_ptr
 *                               Pixels changed map
 *                      UINT8  * SgcPtr
 *								 Level change score.
 *                      INT8   * DispFragPtr
 *                               Block update map.
 *                      INT32  * RowDiffsPtr
 *								 Total sig changes for row
 *                      UINT8  * ChLocalsPtr
 *                               Changed locals data structure
 *
 *
 *  RETURNS       :     
 *
 *  FUNCTION      :     Initial pixel differences scan
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/   
void RowDiffScan( PP_INSTANCE *ppi, UINT8 * YuvPtr1, UINT8 * YuvPtr2, 
                  INT16 * YUVDiffsPtr, UINT8 * bits_map_ptr, 
                  INT8  * SgcPtr, INT8  * DispFragPtr, 
				  UINT8 * FDiffPixels, INT32 * RowDiffsPtr, 
                  UINT8 * ChLocalsPtr, BOOL EdgeRow )
{
    INT32 i;
    INT32 FragChangedPixels;

    INT16 Diff[8];

    UINT32  ZeroData[2] = { 0,0 };
    UINT8   OneData[8] = { 1,1,1,1,1,1,1,1 };
    UINT8   ChlocalsDummyData[8] = { 8,8,8,8,8,8,8,8 };

    // Cannot use kernel if at edge or if PAK disabled
    if ( (!ppi->PAKEnabled) || EdgeRow )
    {
        for ( i = 0; i < ppi->PlaneWidth; i += ppi->HFragPixels )
        {
            // Reset count of pixels changed for the current fragment.
            FragChangedPixels = 0;

            // Test for break out conditions to save time. 
			if ((*DispFragPtr == CANDIDATE_BLOCK) )//|| !ppi->EarlyBreakAllowed)
			{
                
				__asm
				{
				
					movd		esi, [YuvPtr1];
					movd		ebx, [YuvPtr2];
					movd		edx, FragChangedPixels
					pxor		mm7, mm7;

					movq		mm0, [esi]			;76543210
					movq		mm1, [ebx]			;76543210

					movq		mm2, mm0			;make a copy
					movq		mm3, mm1			;make a copy

					punpcklbw	mm0, mm7			; 3 2 1 0
					punpcklbw	mm1, mm7			; 3 2 1 0

					punpckhbw	mm2, mm7			; 7 6 5 4
					punpckhbw   mm3, mm7			; 7 6 5 4

					psubw		mm0	 mm1			; Diff[3,2,1,0]
					psubw		mm2, mm3			; Diff[7,6,5,4]
					
					movq		QWORD PTR [YUVDiffsPtr], mm0
					movq		QWORD PTR [YUVDiffsPtr], mm2					

				;------------------------------------------------------
				;	mm0, mm1, mm3, mm4, m5, mm6, mm7, Free		
				;	mm2, keep the Diff[7 6 5 4]
				;------------------------------------------------------
					
					movd		eax, ppi->LevelThresh

					movd		mm1, eax			;
					movd		mm3, eax			;
					
					packsdw		mm1, mm3			;
					movq		mm4, mm1			;
					
					psllw		mm1, 16
					por			mm1, mm4			;4 ppi->LevelThresh
					

				;-------------------------------------------------------
				;	mm3, mm4, mm5, mm6, mm7 Free
				;   
				;-------------------------------------------------------

					movd		eax, ppi->SrfThresh
					
					movd		mm3, eax			;
					movd		mm4, eax			;

					packsdw		mm3, mm4			;
					movq		mm5, mm3			;

					psllw		mm3, 16
					por			mm3, mm6			;4 ppi->SrfThresh

				;--------------------------------------------------------
				;	mm0 mm2		diff[0]-diff[7]
				;	mm1			ppi->LevelThresh
				;	mm3			ppi->SrfThresh
				;	mm4-mm7		free
				;	Note,	ppi->NegLevelThresh = - ppi->LevelThresh
				;			ppi->NegSrfThresh = - ppi->SrfThresh
				;--------------------------------------------------------

					movq		mm4, mm0			; diff[0][1][2][3]
					movq		mm5, mm0			;

					psubsw		mm4, mm1			; if diff >= LevelThresh
					psraw		mm4, 15				; 00s(True) and ffs (False)
					pandn		mm4, FFFFFFFFh		; ffs(True) and 00s (False)
					psrlw		mm4, 15				; 01 (True) and 00	(False)

					pcmpgtw		mm5, mm3			; if diff > SrfThresh
													; ffs(True) and 00s (False)
					psrlw		mm5, 15				; 01 (True) and 00  (False)					
					pand		mm5, mm4			; 

					
					movq		mm7, mm0			; save a copy of diff[0][1][2][3]
					pxor		mm6, mm6			; clear MM6

					psubsw		mm6, mm1			; mm6 = NegLevelThresh
					pcmpgtw		mm0, mm6			; if diff > NegLevelThresh
													; ffs(True) and 00s (False)
					pandn		mm0, FFFFFFFFh		; if diff <= NegLevelThresh
													; ffs(True) and 00	(False)
					psrlw		mm0, 15				; 01 (True) and 00  (False)

					paddsw		mm7, mm3			; if diff < -NegSrfThresh
					psraw		mm7, 15				; ffs(True)	and 00s (False)
					
					psrlw	    mm7, 15				; 01 (True) and 00s (False)
					pand		mm7, mm0			;
					
				;----------------------------------------------------------------------------
				; mm0, mm1, mm2, mm3, mm4, mm5, mm7		 in use
				; mm6	free
				;----------------------------------------------------------------------------
					
					por			mm5, mm7			; mm7 is free now
					pxor		mm6, mm6			;
					movq		mm7, mm5			;
					punpcklwd	mm5, mm6			;
					punpckhwd	mm7, mm6			;

					paddw		mm5, mm7			;
					movq		mm7, mm5			;

					psrlq		mm7, 32				;
					paddd		mm7, mm5			;

					movd		eax, mm7			;
					
					add			eax, ebx

					


				// Calculate the diference values and copy to YUVDiffsPtr
				Diff[0] = ((INT16)YuvPtr1[0]) - ((INT16)YuvPtr2[0]);
			    Diff[1] = ((INT16)YuvPtr1[1]) - ((INT16)YuvPtr2[1]);
			    Diff[2] = ((INT16)YuvPtr1[2]) - ((INT16)YuvPtr2[2]);
			    Diff[3] = ((INT16)YuvPtr1[3]) - ((INT16)YuvPtr2[3]);
                ((INT32 *)YUVDiffsPtr)[0] = ((INT32 *)Diff)[0];
                ((INT32 *)YUVDiffsPtr)[1] = ((INT32 *)Diff)[1];

				// Test against the Level and ppi->SRF thresholds and record the results
                // Pixel 0
				if ( Diff[0] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[0] > ppi->SrfThresh )
					{          
						bits_map_ptr[0] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[0] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[0] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[0] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 1
				if ( Diff[1] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[1] > ppi->SrfThresh )
					{          
						bits_map_ptr[1] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[1] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[1] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[1] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 2
				if ( Diff[2] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[2] > ppi->SrfThresh )
					{          
						bits_map_ptr[2] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[2] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[2] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[2] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 3
				if ( Diff[3] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[3] > ppi->SrfThresh )
					{          
						bits_map_ptr[3] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[3] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[3] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[3] = 1;
						FragChangedPixels++;
					}
				}

                // Clear down entries in changed locals array
                ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ZeroData)[0];

                // Calculate the diference values and copy to YUVDiffsPtr
			    Diff[4] = ((INT16)YuvPtr1[4]) - ((INT16)YuvPtr2[4]);
			    Diff[5] = ((INT16)YuvPtr1[5]) - ((INT16)YuvPtr2[5]);
			    Diff[6] = ((INT16)YuvPtr1[6]) - ((INT16)YuvPtr2[6]);
			    Diff[7] = ((INT16)YuvPtr1[7]) - ((INT16)YuvPtr2[7]);
                ((INT32 *)YUVDiffsPtr)[2] = ((INT32 *)Diff)[2];
                ((INT32 *)YUVDiffsPtr)[3] = ((INT32 *)Diff)[3];

				// Test against the Level and ppi->SRF thresholds and record the results
                // Pixel 4
				if ( Diff[4] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[4] > ppi->SrfThresh )
					{          
						bits_map_ptr[4] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[4] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[4] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[4] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 5
				if ( Diff[5] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[5] > ppi->SrfThresh )
					{          
						bits_map_ptr[5] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[5] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[5] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[5] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 6
				if ( Diff[6] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[6] > ppi->SrfThresh )
					{          
						bits_map_ptr[6] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[6] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[6] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[6] = 1;
						FragChangedPixels++;
					}
				}
                // Pixel 7
				if ( Diff[7] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;
					if ( Diff[7] > ppi->SrfThresh )
					{          
						bits_map_ptr[7] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[7] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;
					if ( Diff[7] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[7] = 1;
						FragChangedPixels++;
					}
				}

                // Clear down entries in changed locals array
                ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ZeroData)[1];
	        }
            else
            {
                // For EBO coded blocks mark all pixels as changed.
                if ( *DispFragPtr > BLOCK_NOT_CODED )
                {
                    ((UINT32 *)bits_map_ptr)[0] = ((UINT32 *)OneData)[0];
                    ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ChlocalsDummyData)[0];
                    ((UINT32 *)bits_map_ptr)[1] = ((UINT32 *)OneData)[1];
                    ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ChlocalsDummyData)[1];
                }
                else
                {
                    ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ZeroData)[0];
                    ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ZeroData)[1];
                }
            }

			*RowDiffsPtr += FragChangedPixels;
			*FDiffPixels += (UINT8)FragChangedPixels;

			YuvPtr1 += ppi->HFragPixels;
			YuvPtr2 += ppi->HFragPixels;
			bits_map_ptr += ppi->HFragPixels;
            ChLocalsPtr += ppi->HFragPixels;
			YUVDiffsPtr += ppi->HFragPixels;
			SgcPtr ++;
			FDiffPixels ++;

			// If we have a lot of changed pixels for this fragment on this row then 
			// the fragment is almost sure to be picked (e.g. through the line search) so we
			// can mark it as selected and then ignore it.
			// if ( ppi->EarlyBreakAllowed )
			{
				if (FragChangedPixels >= 7)
				{
					*DispFragPtr = BLOCK_CODED;
				}
			}
			DispFragPtr++;    
		}
    }
    else
    {
        for ( i = 0; i < ppi->PlaneWidth; i += ppi->HFragPixels )
        {
            // Reset count of pixels changed for the current fragment.
            FragChangedPixels = 0;

            // Test for break out conditions to save time. 
			if ((*DispFragPtr == CANDIDATE_BLOCK) )//|| !ppi->EarlyBreakAllowed)
			{
                // Calculate the diference values and copy to YUVDiffsPtr
			    Diff[0] = ((INT16)YuvPtr1[0]) - ((INT16)YuvPtr2[0]);
			    Diff[1] = ((INT16)YuvPtr1[1]) - ((INT16)YuvPtr2[1]);
			    Diff[2] = ((INT16)YuvPtr1[2]) - ((INT16)YuvPtr2[2]);
			    Diff[3] = ((INT16)YuvPtr1[3]) - ((INT16)YuvPtr2[3]);
                ((INT32 *)YUVDiffsPtr)[0] = ((INT32 *)Diff)[0];
                ((INT32 *)YUVDiffsPtr)[1] = ((INT32 *)Diff)[1];

				// Test against the Level and ppi->SRF thresholds and record the results
                // Pixel 0
				if ( Diff[0] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[0] > ppi->SrfThresh) && (Diff[0] <= ppi->HighChange) )
						Diff[0] = (int)ApplyPakLowPass( ppi, &YuvPtr1[0] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[0] );

					if ( Diff[0] > ppi->SrfThresh )
					{          
						bits_map_ptr[0] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[0] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[0] < ppi->NegSrfThresh) && (Diff[0] >= ppi->NegHighChange) )
						Diff[0] = (int)ApplyPakLowPass( ppi, &YuvPtr1[0] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[0] );

					if ( Diff[0] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[0] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 1
				if ( Diff[1] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[1] > ppi->SrfThresh) && (Diff[1] <= ppi->HighChange) )
						Diff[1] = (int)ApplyPakLowPass( ppi, &YuvPtr1[1] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[1] );

					if ( Diff[1] > ppi->SrfThresh )
					{          
						bits_map_ptr[1] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[1] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[1] < ppi->NegSrfThresh) && (Diff[1] >= ppi->NegHighChange) )
						Diff[1] = (int)ApplyPakLowPass( ppi, &YuvPtr1[1] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[1] );

					if ( Diff[1] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[1] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 2
				if ( Diff[2] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[2] > ppi->SrfThresh) && (Diff[2] <= ppi->HighChange) )
						Diff[2] = (int)ApplyPakLowPass( ppi, &YuvPtr1[2] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[2] );

					if ( Diff[2] > ppi->SrfThresh )
					{          
						bits_map_ptr[2] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[2] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[2] < ppi->NegSrfThresh) && (Diff[2] >= ppi->NegHighChange) )
						Diff[2] = (int)ApplyPakLowPass( ppi, &YuvPtr1[2] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[2] );

					if ( Diff[2] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[2] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 3
				if ( Diff[3] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[3] > ppi->SrfThresh) && (Diff[3] <= ppi->HighChange) )
						Diff[3] = (int)ApplyPakLowPass( ppi, &YuvPtr1[3] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[3] );

					if ( Diff[3] > ppi->SrfThresh )
					{          
						bits_map_ptr[3] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[3] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[3] < ppi->NegSrfThresh) && (Diff[3] >= ppi->NegHighChange) )
						Diff[3] = (int)ApplyPakLowPass( ppi, &YuvPtr1[3] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[3] );

					if ( Diff[3] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[3] = 1;
						FragChangedPixels++;
					}
    			}

                // Clear down entries in changed locals array
                ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ZeroData)[0];

                // Calculate the diference values and copy to YUVDiffsPtr
			    Diff[4] = ((INT16)YuvPtr1[4]) - ((INT16)YuvPtr2[4]);
			    Diff[5] = ((INT16)YuvPtr1[5]) - ((INT16)YuvPtr2[5]);
			    Diff[6] = ((INT16)YuvPtr1[6]) - ((INT16)YuvPtr2[6]);
			    Diff[7] = ((INT16)YuvPtr1[7]) - ((INT16)YuvPtr2[7]);
                ((INT32 *)YUVDiffsPtr)[2] = ((INT32 *)Diff)[2];
                ((INT32 *)YUVDiffsPtr)[3] = ((INT32 *)Diff)[3];

				// Test against the Level and ppi->SRF thresholds and record the results
                // Pixel 4
				if ( Diff[4] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[4] > ppi->SrfThresh) && (Diff[4] <= ppi->HighChange) )
						Diff[4] = (int)ApplyPakLowPass( ppi, &YuvPtr1[4] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[4] );

					if ( Diff[4] > ppi->SrfThresh )
					{          
						bits_map_ptr[4] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[4] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[4] < ppi->NegSrfThresh) && (Diff[4] >= ppi->NegHighChange) )
						Diff[4] = (int)ApplyPakLowPass( ppi, &YuvPtr1[4] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[4] );

					if ( Diff[4] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[4] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 5
				if ( Diff[5] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[5] > ppi->SrfThresh) && (Diff[5] <= ppi->HighChange) )
						Diff[5] = (int)ApplyPakLowPass( ppi, &YuvPtr1[5] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[5] );

					if ( Diff[5] > ppi->SrfThresh )
					{          
						bits_map_ptr[5] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[5] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[5] < ppi->NegSrfThresh) && (Diff[5] >= ppi->NegHighChange) )
						Diff[5] = (int)ApplyPakLowPass( ppi, &YuvPtr1[5] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[5] );

					if ( Diff[5] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[5] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 6
				if ( Diff[6] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
			        if ( (Diff[6] > ppi->SrfThresh) && (Diff[6] <= ppi->HighChange) )
						Diff[6] = (int)ApplyPakLowPass( ppi, &YuvPtr1[6] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[6] );

					if ( Diff[6] > ppi->SrfThresh )
					{          
						bits_map_ptr[6] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[6] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[6] < ppi->NegSrfThresh) && (Diff[6] >= ppi->NegHighChange) )
						Diff[6] = (int)ApplyPakLowPass( ppi, &YuvPtr1[6] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[6] );

					if ( Diff[6] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[6] = 1;
						FragChangedPixels++;
					}
    			}

                // Pixel 7
				if ( Diff[7] >= ppi->LevelThresh )
				{         
					SgcPtr[0]++;

					// If the level change is still suspect then apply PAK kernel.
			        if ( (Diff[7] > ppi->SrfThresh) && (Diff[7] <= ppi->HighChange) )
						Diff[7] = (int)ApplyPakLowPass( ppi, &YuvPtr1[7] ) - 
							      (int)ApplyPakLowPass( ppi, &YuvPtr2[7] );

					if ( Diff[7] > ppi->SrfThresh )
					{          
						bits_map_ptr[7] = 1;
						FragChangedPixels++;
					}    
				}
				else if ( Diff[7] <= ppi->NegLevelThresh )
				{
					SgcPtr[0]--;

					// If the level change is still suspect then apply PAK kernel.
					if ( (Diff[7] < ppi->NegSrfThresh) && (Diff[7] >= ppi->NegHighChange) )
						Diff[7] = (int)ApplyPakLowPass( ppi, &YuvPtr1[7] ) - 
                                  (int)ApplyPakLowPass( ppi, &YuvPtr2[7] );

					if ( Diff[7] < ppi->NegSrfThresh )
					{          
						bits_map_ptr[7] = 1;
						FragChangedPixels++;
					}
    			}

                // Clear down entries in changed locals array
                ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ZeroData)[1];
            }
            else
            {
                // For EBO coded blocks mark all pixels as changed.
                if ( *DispFragPtr > BLOCK_NOT_CODED )
                {
                    ((UINT32 *)bits_map_ptr)[0] = ((UINT32 *)OneData)[0];
                    ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ChlocalsDummyData)[0];

                    ((UINT32 *)bits_map_ptr)[1] = ((UINT32 *)OneData)[1];
                    ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ChlocalsDummyData)[1];
                }
                else
                {
                    ((UINT32 *)ChLocalsPtr)[0] = ((UINT32 *)ZeroData)[0];
                    ((UINT32 *)ChLocalsPtr)[1] = ((UINT32 *)ZeroData)[1];
                }
            }

			*RowDiffsPtr += FragChangedPixels;
			*FDiffPixels += (UINT8)FragChangedPixels;

            YuvPtr1 += ppi->HFragPixels;
            YuvPtr2 += ppi->HFragPixels;
            bits_map_ptr += ppi->HFragPixels;
            ChLocalsPtr += ppi->HFragPixels;
            YUVDiffsPtr += ppi->HFragPixels;
            SgcPtr ++;
			FDiffPixels ++;

			// If we have a lot of changed pixels for this fragment on this row then 
			// the fragment is almost sure to be picked (e.g. through the line search) so we
			// can mark it as selected and then ignore it.
//			if ( ppi->EarlyBreakAllowed )
			{
				if (FragChangedPixels >= 7)
				{
					*DispFragPtr = BLOCK_CODED;
				}
			}
			DispFragPtr++;    
        }
    }
}