/****************************************************************************
*
* 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++;
}
}
}