/****************************************************************************
*
* Module Title : newLoopTest_asm.c
*
* Description : Codec specific functions
*
* AUTHOR : Yaowu Xu
*
*****************************************************************************
* Revision History
*
* 1.02 YWX 03-Nov-00 Changed confusing variable name
* 1.01 YWX 02-Nov-00 Added the set of functions
* 1.00 YWX 19-Oct-00 configuration baseline
*****************************************************************************
*/
/****************************************************************************
* Header Frames
*****************************************************************************
*/
#define STRICT /* Strict type checking. */
#include "codec_common.h"
#include <math.h>
/****************************************************************************
* Module constants.
*****************************************************************************
*/
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define FILTER_WEIGHT 128
#define FILTER_SHIFT 7
__declspec(align(16)) short rd[]={64,64,64,64,64,64,64,64};
__declspec(align(16)) INT16 BilinearFilters_wmt[8][16] =
{
{ 128,128,128,128,128,128,128,128, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 112,112,112,112,112,112,112,112, 16, 16, 16, 16, 16, 16, 16, 16 },
{ 96, 96, 96, 96, 96, 96, 96, 96, 32, 32, 32, 32, 32, 32, 32, 32 },
{ 80, 80, 80, 80, 80, 80, 80, 80, 48, 48, 48, 48, 48, 48, 48, 48 },
{ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 },
{ 48, 48, 48, 48, 48, 48, 48, 48, 80, 80, 80, 80, 80, 80, 80, 80 },
{ 32, 32, 32, 32, 32, 32, 32, 32, 96, 96, 96, 96, 96, 96, 96, 96 },
{ 16, 16, 16, 16, 16, 16, 16, 16, 112,112,112,112,112,112,112,112 }
};
extern __declspec(align(16)) INT16 BicubicFilters_mmx[17][8][32];
_inline
void FilterBlock1d_h_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 SrcPixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi+ 16] ; xmm3 *= kernel 0 modifiers.
movdqa xmm6, [edi + 32] ; xmm3 *= kernel 0 modifiers.
movdqa xmm7, [edi + 48] ; xmm3 *= kernel 0 modifiers.
mov edi,OutputPtr
mov esi,SrcPtr
dec esi
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
// kernel 0 and 3 are potentially negative taps. These negative tap filters
// must be done first or we could have problems saturating our high value
// tap filters
movdqu xmm3, [esi] ; xmm3 = p-1..p14
movdqu xmm4, xmm3 ; xmm4 = p-1..p14
punpcklbw xmm3, xmm0 ; xmm3 = p-1..p6
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
psrldq xmm4, 3 ; xmm4 = p2..p13
movdqa xmm5, xmm4 ; xmm5 = p2..p13
punpcklbw xmm5, xmm0 ; xmm5 = p2..p7
pmullw xmm5, xmm7 ; xmm5 *= kernel 3 modifiers
paddsw xmm3, xmm5 ; xmm3 += xmm5
movdqu xmm4, [esi+1] ; xmm4 = p0..p13
movdqa xmm5, xmm4 ; xmm5 = p0..p13
punpcklbw xmm5, xmm0 ; xmm5 = p0..p7
pmullw xmm5, xmm2 ; xmm5 *= kernel 1 modifiers
paddsw xmm3, xmm5 ; xmm3 += xmm5
psrldq xmm4, 1 ; xmm4 = p1..p13
movdqa xmm5, xmm4 ; xmm5 = p1..p13
punpcklbw xmm5, xmm0 ; xmm5 = p1..p7
pmullw xmm5, xmm6 ; xmm5 *= kernel 2 modifiers
paddsw xmm3, xmm5 ; xmm3 += xmm5
paddsw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
packuswb xmm3, xmm0 ; pack and saturate
movdq2q mm0, xmm3
movq [edi],mm0 ; store the results in the destination
add esi,SrcPixelsPerLine ; next line
add edi,eax;
dec ecx ; decrement count
jnz nextrow ; next row
}
}
_inline
void FilterBlock1d_v_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 PixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi + 16] ; xmm3 *= kernel 0 modifiers.
movdqa xmm6, [edi + 32] ; xmm3 *= kernel 0 modifiers.
movdqa xmm7, [edi + 48] ; xmm3 *= kernel 0 modifiers.
mov edx, PixelsPerLine
mov edi, OutputPtr
mov esi, SrcPtr
sub esi, PixelsPerLine
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p0..p16
punpcklbw xmm3, xmm0 ; xmm3 = p0..p8
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
add esi, edx ; move source forward 1 line to avoid 3 * pitch
movdqu xmm4, [esi+2*edx] ; xmm4 = p0..p16
punpcklbw xmm4, xmm0 ; xmm4 = p0..p8
pmullw xmm4, xmm7 ; xmm4 *= kernel 3 modifiers.
paddsw xmm3, xmm4 ; xmm3 += xmm4
movdqu xmm4, [esi ] ; xmm4 = p0..p16
punpcklbw xmm4, xmm0 ; xmm4 = p0..p8
pmullw xmm4, xmm2 ; xmm4 *= kernel 1 modifiers.
paddsw xmm3, xmm4 ; xmm3 += xmm4
movdqu xmm4, [esi +edx] ; xmm4 = p0..p16
punpcklbw xmm4, xmm0 ; xmm4 = p0..p8
pmullw xmm4, xmm6 ; xmm4 *= kernel 2 modifiers.
paddsw xmm3, xmm4 ; xmm3 += xmm4
paddsw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
packuswb xmm3, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm3
movq [edi],mm0 ; store the results in the destination
// the subsequent iterations repeat 3 out of 4 of these reads. Since the
// recon block should be in cache this shouldn't cost much. Its obviously
// avoidable!!!.
add edi,eax;
dec ecx ; decrement count
jnz nextrow ; next row
}
}
_inline
void FilterBlock1d_hb8_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 SrcPixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi + 16] ; xmm3 *= kernel 0 modifiers.
mov edi,OutputPtr
mov esi,SrcPtr
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p-1..p14
movdqu xmm5, xmm3 ; xmm4 = p-1..p14
punpcklbw xmm3, xmm0 ; xmm3 = p-1..p6
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
psrldq xmm5, 1 ; xmm4 = p0..p13
punpcklbw xmm5, xmm0 ; xmm5 = p0..p7
pmullw xmm5, xmm2 ; xmm5 *= kernel 1 modifiers
paddw xmm3, xmm5 ; xmm3 += xmm5
paddw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
packuswb xmm3, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm3
movq [edi],mm0 ; store the results in the destination
add esi,SrcPixelsPerLine ; next line
add edi,eax;
dec ecx ; decrement count
jnz nextrow ; next row
}
}
_inline
void FilterBlock1d_vb8_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 PixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi + 16] ; xmm3 *= kernel 0 modifiers.
mov edx, PixelsPerLine
mov edi, OutputPtr
mov esi, SrcPtr
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p0..p16
punpcklbw xmm3, xmm0 ; xmm3 = p0..p8
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
movdqu xmm4, [esi +edx ] ; xmm4 = p0..p16
punpcklbw xmm4, xmm0 ; xmm4 = p0..p8
pmullw xmm4, xmm2 ; xmm4 *= kernel 1 modifiers.
paddw xmm3, xmm4 ; xmm3 += xmm4
paddw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
packuswb xmm3, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm3
movq [edi],mm0 ; store the results in the destination
// the subsequent iterations repeat 3 out of 4 of these reads. Since the
// recon block should be in cache this shouldn't cost much. Its obviously
// avoidable!!!.
add esi,edx
add edi,eax
dec ecx ; decrement count
jnz nextrow ; next row
}
}
/****************************************************************************
*
* ROUTINE : FilterBlock2dBil
*
* INPUTS : Pointer to source data
*
* OUTPUTS : Filtered data
*
* RETURNS : None.
*
* FUNCTION : Applies a bilinear filter on the intput data to produce
* a predictor block (UINT16)
*
* SPECIAL NOTES :
*
* ERRORS : None.
*
****************************************************************************/
_inline
void FilterBlock2dBil_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 SrcPixelsPerLine, INT16 * HFilter, INT16 * VFilter )
{
__asm
{
mov eax, HFilter ;
mov edi, OutputPtr ;
mov esi, SrcPtr ;
lea ecx, [edi+64] ;
mov edx, SrcPixelsPerLine ;
movdqa xmm1, [eax] ;
movdqa xmm2, [eax+16] ;
mov eax, VFilter ;
pxor xmm0, xmm0 ;
// get the first horizontal line done ;
movdqu xmm3, [esi] ; xx 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14
movdqa xmm4, xmm3 ; make a copy of current line
punpcklbw xmm3, xmm0 ; xx 00 01 02 03 04 05 06
psrldq xmm4, 1 ; 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 xx
pmullw xmm3, xmm1 ;
punpcklbw xmm4, xmm0 ; 00 01 02 03 04 05 06 07
pmullw xmm4, xmm2 ;
paddw xmm3, xmm4 ;
paddw xmm3, rd ;
psraw xmm3, FILTER_SHIFT ; ready for output
movdqa xmm5, xmm3 ;
add esi, edx ; next line
NextRow:
pmullw xmm5, [eax] ;
movdqu xmm3, [esi] ; xx 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14
movdqa xmm4, xmm3 ; make a copy of current line
punpcklbw xmm3, xmm0 ; xx 00 01 02 03 04 05 06
psrldq xmm4, 1 ; 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 xx
pmullw xmm3, xmm1 ;
punpcklbw xmm4, xmm0 ; 00 01 02 03 04 05 06 07
movdqa xmm6, xmm5 ;
pmullw xmm4, xmm2 ;
paddw xmm3, xmm4 ;
paddw xmm3, rd ;
psraw xmm3, FILTER_SHIFT ; ready for output
movdqa xmm5, xmm3 ; make a copy for the next row
pmullw xmm3, [eax+16] ;
paddw xmm6, xmm3 ;
paddw xmm6, rd ; xmm6 += round value
psraw xmm6, FILTER_SHIFT ; xmm6 /= 128
packuswb xmm6, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm6
movq [edi], mm0 ; store the results in the destination
add esi, edx ; next line
add edi, 8 ;
cmp edi, ecx ;
jne NextRow
}
// First filter 1d Horizontal
//FilterBlock1d_hb8_wmt(SrcPtr, Intermediate, SrcPixelsPerLine, 1, 9, 8, HFilter );
// Now filter Verticaly
//FilterBlock1d_vb8_wmt(Intermediate, OutputPtr, BLOCK_HEIGHT_WIDTH, BLOCK_HEIGHT_WIDTH, 8, 8, VFilter);
}
_inline
void FilterUnpackBlock2dBil_wmt( UINT8 *SrcPtr, INT16 *OutputPtr, UINT32 SrcPixelsPerLine, INT16 * HFilter, INT16 * VFilter )
{
__asm
{
mov eax, HFilter ;
mov edi, OutputPtr ;
mov esi, SrcPtr ;
lea ecx, [edi+128] ;
mov edx, SrcPixelsPerLine ;
movdqa xmm1, [eax] ;
movdqa xmm2, [eax+16] ;
mov eax, VFilter ;
pxor xmm0, xmm0 ;
// get the first horizontal line done ;
movdqu xmm3, [esi] ; xx 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14
movdqa xmm4, xmm3 ; make a copy of current line
punpcklbw xmm3, xmm0 ; xx 00 01 02 03 04 05 06
psrldq xmm4, 1 ; 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 xx
pmullw xmm3, xmm1 ;
punpcklbw xmm4, xmm0 ; 00 01 02 03 04 05 06 07
pmullw xmm4, xmm2 ;
paddw xmm3, xmm4 ;
paddw xmm3, rd ;
psraw xmm3, FILTER_SHIFT ; ready for output
movdqa xmm5, xmm3 ;
add esi, edx ; next line
NextRow:
pmullw xmm5, [eax] ;
movdqu xmm3, [esi] ; xx 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14
movdqa xmm4, xmm3 ; make a copy of current line
punpcklbw xmm3, xmm0 ; xx 00 01 02 03 04 05 06
psrldq xmm4, 1 ; 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 xx
pmullw xmm3, xmm1 ;
punpcklbw xmm4, xmm0 ; 00 01 02 03 04 05 06 07
movdqa xmm6, xmm5 ;
pmullw xmm4, xmm2 ;
paddw xmm3, xmm4 ;
paddw xmm3, rd ;
psraw xmm3, FILTER_SHIFT ; ready for output
movdqa xmm5, xmm3 ; make a copy for the next row
pmullw xmm3, [eax+16] ;
paddw xmm6, xmm3 ;
paddw xmm6, rd ; xmm6 += round value
psraw xmm6, FILTER_SHIFT ; xmm6 /= 128
movdqu [edi], xmm6;
/*
packuswb xmm6, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm6
movq [edi], mm0 ; store the results in the destination
*/
add esi, edx ; next line
add edi, 16 ;
cmp edi, ecx ;
jne NextRow
}
// First filter 1d Horizontal
//FilterBlock1d_hb8_wmt(SrcPtr, Intermediate, SrcPixelsPerLine, 1, 9, 8, HFilter );
// Now filter Verticaly
//FilterBlock1d_vb8_wmt(Intermediate, OutputPtr, BLOCK_HEIGHT_WIDTH, BLOCK_HEIGHT_WIDTH, 8, 8, VFilter);
}
_inline
void FilterUnpackBlock1d_hb8_wmt( UINT8 *SrcPtr, INT16 *OutputPtr, UINT32 SrcPixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi + 16] ; xmm3 *= kernel 0 modifiers.
mov edi,OutputPtr
mov esi,SrcPtr
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p-1..p14
movdqu xmm5, xmm3 ; xmm4 = p-1..p14
punpcklbw xmm3, xmm0 ; xmm3 = p-1..p6
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
psrldq xmm5, 1 ; xmm4 = p0..p13
punpcklbw xmm5, xmm0 ; xmm5 = p0..p7
pmullw xmm5, xmm2 ; xmm5 *= kernel 1 modifiers
paddw xmm3, xmm5 ; xmm3 += xmm5
paddw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
/*
packuswb xmm3, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm3
*/
movdqu [edi],xmm3 ; store the results in the destination
add esi,SrcPixelsPerLine ; next line
add edi,eax;
dec ecx ; decrement count
jnz nextrow ; next row
}
}
_inline
void FilterUnpackBlock1d_vb8_wmt( UINT8 *SrcPtr, INT16 *OutputPtr, UINT32 PixelsPerLine, UINT32 PixelStep, UINT32 OutputHeight, UINT32 OutputWidth, INT16 * Filter )
{
__asm
{
mov edi, Filter
movdqa xmm1, [edi] ; xmm3 *= kernel 0 modifiers.
movdqa xmm2, [edi + 16] ; xmm3 *= kernel 0 modifiers.
mov edx, PixelsPerLine
mov edi, OutputPtr
mov esi, SrcPtr
mov ecx, DWORD PTR OutputHeight
mov eax, OutputWidth ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p0..p16
punpcklbw xmm3, xmm0 ; xmm3 = p0..p8
pmullw xmm3, xmm1 ; xmm3 *= kernel 0 modifiers.
movdqu xmm4, [esi +edx ] ; xmm4 = p0..p16
punpcklbw xmm4, xmm0 ; xmm4 = p0..p8
pmullw xmm4, xmm2 ; xmm4 *= kernel 1 modifiers.
paddw xmm3, xmm4 ; xmm3 += xmm4
paddw xmm3, rd ; xmm3 += round value
psraw xmm3, FILTER_SHIFT ; xmm3 /= 128
/*packuswb xmm3, xmm0 ; pack and unpack to saturate
movdq2q mm0, xmm3
*/
movdqu [edi],xmm3 ; store the results in the destination
// the subsequent iterations repeat 3 out of 4 of these reads. Since the
// recon block should be in cache this shouldn't cost much. Its obviously
// avoidable!!!.
add esi,edx
add edi,eax
dec ecx ; decrement count
jnz nextrow ; next row
}
}
/****************************************************************************
*
* ROUTINE : FilterBlockBil_8
*
* INPUTS : ReconPtr1, ReconPtr12
* Two pointers into the block of data to be filtered
* These pointers bound the fractional pel position
* PixelsPerLine
* Pixels per line in the buffer pointed to by ReconPtr1 & ReconPtr12
* Modx, ModY
* The fractional pel bits used to select a filter.
*
*
* OUTPUTS : ReconRefPtr
* A pointer to an 8x8 buffer into which UINT8 filtered data is written.
*
* RETURNS : None.
*
* FUNCTION : Produces a bilinear filtered fractional pel prediction block
* with UINT8 output
*
* SPECIAL NOTES :
*
* ERRORS : None.
*
****************************************************************************/
void FilterBlockBil_8_wmt( UINT8 *ReconPtr1, UINT8 *ReconPtr2, UINT8 *ReconRefPtr, UINT32 PixelsPerLine, INT32 ModX, INT32 ModY )
{
int diff;
// swap pointers so ReconPtr1 smaller (above, left, above-right or above-left )
diff=ReconPtr2-ReconPtr1;
// The ModX and ModY arguments are the bottom three bits of the signed motion vector components (at 1/8th pel precision).
// This works out to be what we want... despite the pointer swapping that goes on below.
// For example... if the X component of the vector is a +ve ModX = X%8.
// if the X component of the vector is a -ve ModX = 8+(X%8) where X%8 is in the range -7 to -1.
if(diff<0)
{ // swap pointers so ReconPtr1 smaller
UINT8 *temp=ReconPtr1;
ReconPtr1=ReconPtr2;
ReconPtr2=temp;
diff= (int)(ReconPtr2-ReconPtr1);
}
if( diff==1 )
{
FilterBlock1d_hb8_wmt(ReconPtr1, ReconRefPtr, PixelsPerLine, 1, 8, 8, BilinearFilters_wmt[ModX] );
}
else if (diff == (int)(PixelsPerLine) ) // Fractional pixel in vertical only
{
FilterBlock1d_vb8_wmt(ReconPtr1, ReconRefPtr, PixelsPerLine, PixelsPerLine, 8, 8, BilinearFilters_wmt[ModY]);
}
else if(diff == (int)(PixelsPerLine - 1)) // ReconPtr1 is Top right
{
FilterBlock2dBil_wmt( ReconPtr1-1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
//FilterBlock2dBil_8_wmt( ReconPtr1-1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
}
else if(diff == (int)(PixelsPerLine + 1) ) // ReconPtr1 is Top left
{
FilterBlock2dBil_wmt( ReconPtr1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
//FilterBlock2dBil_8_wmt( ReconPtr1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
}
}
_inline void UnpackBlock_wmt( UINT8 *SrcPtr, UINT16 *OutputPtr, UINT32 SrcPixelsPerLine )
{
__asm
{
mov edi,OutputPtr
mov esi,SrcPtr
mov ecx, 8
mov eax, 16 ; destination pitch?
pxor xmm0, xmm0 ; xmm0 = 00000000
nextrow:
movdqu xmm3, [esi] ; xmm3 = p-1..p14
punpcklbw xmm3, xmm0 ; xmm3 = p-1..p6
movdqu [edi],xmm3 ; store the results in the destination
add esi,SrcPixelsPerLine ; next line
add edi,eax;
dec ecx ; decrement count
jnz nextrow ; next row
}
}
/****************************************************************************
*
* ROUTINE : FilterBlock2d
*
* INPUTS : Pointer to source data
*
* OUTPUTS : Filtered data
*
* RETURNS : None.
*
* FUNCTION : Applies a 2d 4 tap filter on the intput data to produce
* a predictor block (UINT16)
*
* SPECIAL NOTES :
*
* ERRORS : None.
*
****************************************************************************/
void FilterBlock2d_wmt( UINT8 *SrcPtr, UINT8 *OutputPtr, UINT32 SrcPixelsPerLine, INT16 * HFilter, INT16 * VFilter )
{
UINT8 Intermediate[256];
// First filter 1d Horizontal
FilterBlock1d_h_wmt(SrcPtr-SrcPixelsPerLine, Intermediate, SrcPixelsPerLine, 1, 11, 8, HFilter );
// Now filter Verticaly
FilterBlock1d_v_wmt(Intermediate+BLOCK_HEIGHT_WIDTH, OutputPtr, BLOCK_HEIGHT_WIDTH, BLOCK_HEIGHT_WIDTH, 8, 8, VFilter);
}
/****************************************************************************
*
* ROUTINE : FilterBlock
*
* INPUTS : ReconPtr1, ReconPtr12
* Two pointers into the block of data to be filtered
* These pointers bound the fractional pel position
* PixelsPerLine
* Pixels per line in the buffer pointed to by ReconPtr1 & ReconPtr12
* Modx, ModY
* The fractional pel bits used to select a filter.
* UseBicubic
* Whether to use the bicubuc filter set or the bilinear set
*
*
* OUTPUTS : ReconRefPtr
* A pointer to an 8x8 buffer into which the filtered data is written.
*
* RETURNS : None.
*
* FUNCTION : Produces a filtered fractional pel prediction block
* using bilinear or bicubic filters
*
* SPECIAL NOTES :
*
* ERRORS : None.
*
****************************************************************************/
void FilterBlock_wmt( UINT8 *ReconPtr1, UINT8 *ReconPtr2, UINT16 *ReconRefPtr, UINT32 PixelsPerLine, INT32 ModX, INT32 ModY, BOOL UseBicubic, UINT8 BicubicAlpha )
{
int diff;
UINT8 Intermediate[256];
// swap pointers so ReconPtr1 smaller (above, left, above-right or above-left )
diff=ReconPtr2-ReconPtr1;
// The ModX and ModY arguments are the bottom three bits of the signed motion vector components (at 1/8th pel precision).
// This works out to be what we want... despite the pointer swapping that goes on below.
// For example... if the X component of the vector is a +ve ModX = X%8.
// if the X component of the vector is a -ve ModX = 8+(X%8) where X%8 is in the range -7 to -1.
if(diff<0)
{ // swap pointers so ReconPtr1 smaller
UINT8 *temp=ReconPtr1;
ReconPtr1=ReconPtr2;
ReconPtr2=temp;
diff= (int)(ReconPtr2-ReconPtr1);
}
if(!diff)
{
return;
}
if(UseBicubic)
{
if( diff==1 )
{ // Fractional pixel in horizontal only
FilterBlock1d_h_wmt(ReconPtr1, Intermediate, PixelsPerLine, 1, 8, 8, BicubicFilters_mmx[BicubicAlpha][ModX] );
}
else if (diff == (int)(PixelsPerLine) ) // Fractional pixel in vertical only
{
FilterBlock1d_v_wmt(ReconPtr1, Intermediate, PixelsPerLine, PixelsPerLine, 8, 8, BicubicFilters_mmx[BicubicAlpha][ModY]);
}
else if(diff == (int)(PixelsPerLine - 1)) // ReconPtr1 is Top right
{
FilterBlock2d_wmt( ReconPtr1-1, Intermediate, PixelsPerLine, BicubicFilters_mmx[BicubicAlpha][ModX], BicubicFilters_mmx[BicubicAlpha][ModY] );
}
else if(diff == (int)(PixelsPerLine + 1) ) // ReconPtr1 is Top left
{
FilterBlock2d_wmt( ReconPtr1, Intermediate, PixelsPerLine, BicubicFilters_mmx[BicubicAlpha][ModX], BicubicFilters_mmx[BicubicAlpha][ModY] );
}
UnpackBlock_wmt( Intermediate, ReconRefPtr, 8 );
}
else
{
if( diff==1 )
{
FilterUnpackBlock1d_hb8_wmt(ReconPtr1, ReconRefPtr, PixelsPerLine, 1, 8, 16, BilinearFilters_wmt[ModX] );
// Fractional pixel in horizontal only
/*
FilterBlock1d_hb8_wmt(ReconPtr1, Intermediate, PixelsPerLine, 1, 8, 8, BilinearFilters_wmt[ModX] );
UnpackBlock_wmt( Intermediate, ReconRefPtr, 8 );
*/
}
else if (diff == (int)(PixelsPerLine) ) // Fractional pixel in vertical only
{
FilterUnpackBlock1d_vb8_wmt(ReconPtr1, ReconRefPtr, PixelsPerLine, PixelsPerLine, 8, 16, BilinearFilters_wmt[ModY]);
/*
FilterBlock1d_vb8_wmt(ReconPtr1, Intermediate, PixelsPerLine, PixelsPerLine, 8, 8, BilinearFilters_wmt[ModY]);
UnpackBlock_wmt( Intermediate, ReconRefPtr, 8 );
*/
}
else if(diff == (int)(PixelsPerLine - 1)) // ReconPtr1 is Top right
{
FilterUnpackBlock2dBil_wmt( ReconPtr1-1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
/*
FilterBlock2dBil_wmt( ReconPtr1-1, Intermediate, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
UnpackBlock_wmt( Intermediate, ReconRefPtr, 8 );
*/
}
else if(diff == (int)(PixelsPerLine + 1) ) // ReconPtr1 is Top left
{
FilterUnpackBlock2dBil_wmt( ReconPtr1, ReconRefPtr, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
/*
FilterBlock2dBil_wmt( ReconPtr1, Intermediate, PixelsPerLine, BilinearFilters_wmt[ModX], BilinearFilters_wmt[ModY] );
UnpackBlock_wmt( Intermediate, ReconRefPtr, 8 );
*/
}
}
}