|
|
|
|
|
|
|
|
|
Information in this document is provided in
connection with Intel products. No license, express or
implied, by estoppel or otherwise, to any intellectual
property rights is granted by this document. Except as
provided in Intel's Terms and Conditions of Sale for such
products, Intel assumes no liability whatsoever, and
Intel disclaims any express or implied warranty, relating
to sale and/or use of Intel products including liability
or warranties relating to fitness for a particular
purpose, merchantability, or infringement of any patent,
copyright or other intellectual property right. Intel
products are not intended for use in medical, life
saving, or life sustaining applications. Intel may make
changes to specifications and product descriptions at any
time, without notice. Copyright (c) Intel Corporation 1997. *Third-party brands and names are the property of their respective owners. |
CONTENTS: |
This application note will cover the optimization techniques used to implement 16-bit alpha blending with a predefined 8-bit mask using MMXTM Technology for Microsoft* DirectDraw. 16-bit alpha blending using 8-bit masks is normally used in image manipulation and anti-aliasing sprites for games. The 16-bit alpha blending routine uses MMX Technology to calculate the alpha blending result for four pixels (per iteration) using 16-bit source, 16-bit destination, and 8-bit alpha bitmaps. This appnote will provide an overview of the alpha blending equation, implementation/optimization techniques for 16-bit RGB alpha blending on a Pentium II(R) Processor, performance results, and functions for 565 and 555 color space alpha blending. The functions provided in this appnote are optimized to work with DirectDraw surfaces in system memory on Pentium II Processors. For a general coverage of alpha blending using MMX Technology please refer to the appnote Using MMX TM Instructions to Implement Alpha Blending.
The technique for alpha blending uses the simple mathmatical function:
Co=Cs*(A)+(1-A)*Cd
Figure 1: Floating Point Alpha Blend Equation
Where the values for C are either the red, green, or blue component of a pixel in the source and destination image. The subscript s denotes the source color and d denotes the destination color. In this equation the source pixels are multiplied by an alpha factor A while the destination pixels are multiplied by the inverse alpha value (1-A). The range for the alpha value in A is between zero and one. Each color component (R,G,B) must have the same dynamic range for the source and destination bitmap (i.e. five bits for red in source and destination). However dynamic ranges between color components (i.e. Red is five bits and Green is six bits) within a pixel need not be the same.
This section describes the various aspects of writing the 16-bit alpha blending routine shown in the Appendix. These factors consist of the make up of function inputs, video hardware, pixel data storage and arrangement, Pentium II Processor cache and instruction execution, integer alpha blending calculations, MMX Technology implementation, work reduction, and video surfaces.
The inputs for both alpha blending routines consist of the memory location, pitch for a row of pixels, and coordinates for the alpha, source, and destination bitmaps (shown in Figure 2). These attributes can be obtained from the DirectDraw data structure DDSURFACEDESC after a call to lock the DirectDraw surface. For the function to work properly the alpha mask must have a one to one mapping with the source surface. The alpha blending is bounded by iDstW(width) and iDstH(height) which limit the operation to a rectangular area for the alpha mask, source bitmap, and destination bitmap.
| void ablend_555(unsigned char
*lpAlpha,unsigned int iAlpPitch, unsigned char *lpSrc,unsigned int iSrcX, unsigned int iSrcY, unsigned int iSrcPitch, unsigned char *lpDst, unsigned int iDstX, unsigned int iDstY, unsigned int iDstW, unsigned int iDstH, unsigned int iDstPitch) |
Figure 2: 555 Alpha Blending Function Prototype
The make up of the video hardware affects the display of the resulting alpha blended image. The image must conform to the bit allocations for the video hardware so that the surface is displayed properly. There are two methods to represent 16-bit color in video hardware. Both methods 555 and 565 describe bit allocations for the RGB color components that make up a pixel. In the case of 555, each color component is allocated five bits with the most significant bit left unused. For 565 the extra bit is use in the green component. The arrangement of color components (either RGB or BRG) is dependent on the implementation of the video hardware.
In DirectDraw applications, the pixel format is video card dependent and stored sequentially in RGB format. This applies to the source and destination bitmaps which use 16-bit RGB color. The alpha mask is stored in memory in eight bit format independent of the video hardware. Knowledge of bitmap and mask storage is useful when attempting to access the pixels for alpha blending via surface pointers. In DirectDraw, surfaces are allocated on four byte boundaries for each row of pixels. A surface that does not fit in the four byte boundaries is padded with extra bytes. For example a DirectDraw surface with dimensions of 23 pixels wide, 23 pixels high, and 16-bit depth, will create a span of 46 bytes per row (23 pixels*2 bytes). However when DirectDraw allocates the memory it will create a surface with a pitch of 48 bytes per row to maintain four byte alignement. Thus the width of some bitmaps will not correspond to the amount of actual system or video memory used by a row of pixels. The padding will skew the pixel accesses for each successive line. To correct the problem pitch is used to advance the surface pointer to the next line of the image.
The two significant features of the Pentium II Processor affecting the implementation of the alpha blending algorithm, are non-aligned cache line access, and dynamic instruction execution. A non-aligned cache line access occurs when an application accesses data on a cache line that is not four byte aligned. For example, when an application accesses a single byte at the beginning of a cache line and then proceeds to access a word or dword, a non-aligned access occurs. On a Pentium Processor with MMX Technology this non-aligned cache line access causes a one cycle penalty each time the data is read from the cache. The Pentium II Processor allows non-aligned cache line accesses without a penalty. Therefore pre and post alignment of data accesses is no longer necessary. The Pentium II Processor also utilizes dynamic execution with instruction look ahead to determine instructions for execution in its five execution units thus doing away with the need for pairing optimizations. Assembly instructions written for the Pentium II Processor will no longer require pre/post data alignment code and pairing optimizations in MMX Technology code.
The equation for alpha blending discussed in Section 2.1 showed that the alpha value was a floating point number between zero and one. However the data for the alpha mask, as well as the source and destination bitmaps are represented in integer format. Since the conversion of each value to floating point for the equation would cost too many cycles, the alpha blending algorithm utilizes an integer scaling factor to calculate color components in integer format. An indepth discussion of integer scaling is described in the November 1995 issue of IEEE Computer Graphics and Applications article ,"Three Wrongs Make a Right" by James F. Blinn. By applying the integer scaling method described in the article, the 555 alpha blending algorithm is reduced to the simple series of shifts and multiplies shown in Figure 3. The alpha value A, which is in eight bits, is scaled by shifting right three bits to a five bit integer.
C1= Cs*(A)+(31-A)*Cd
Co=(C1+16)+((C1+16)>>5)>>5
Figure 3: 5-Bit Integer Alpha Blend Equation
In the case of 565 alpha blending, the green component utilizes the six bit integer alpha blending equation shown in Figure 4. The alpha value A is scaled to a six bit integer by shifting right by two bits.
C1= Cs*(A)+(63-A)*Cd
Co=(C1+32)+((C1+32)>>6)>>6
Figure 4: 6-Bit Integer Alpha Blend Equation
There are two optimizations that improve the performance of the alpha blending by reducing the amount of instructions to be executed. In the first method early out testing, the algorithm takes into account the fact that the alpha blending equation will display destination pixels when the alpha mask is zero and source pixels when the alpha mask is a five or six bit run of ones. By using a simple two dword comparison for a run of zeros and ones the alpha blending equation can be skipped. This method works well for long runs of ones or zeros in the alpha mask (such as a large control panel that is alpha blended against a background image). The second method, pre-processing alpha masks, require that each alpha mask be reduced to the dynamic range of each color component. For 555 alpha blend routine the alpha mask can be preprocessed to a five bit mask value to avoid the in function shift. For the 565 alpha blend algorithm two preproccessed masks are required -- one for five bits (for red and blue calculations) and six bits (for green calculations). This technique was not used in the alpha blending functions below because it is easier to generate an eight bit alpha mask for use in both 565 and 555 alpha blending routines.
The functions provided in the Appendix will operate on surfaces allocated in system or video memory. However when applied to video surfaces (either as a source, destination or both) there will be a significant performance degradation. The degradation occurs when video memory is accessed by the PCI bus from a PCI video card. Every request for a pixel in video memory is passed through the PCI bus which is significantly slower than the memory bus. This is also compounded by non-cacheable video memory so that every time the pixel is reused (such as the case for isolating the RGB components of the pixel in the algorithm below) a request is places on the PCI bus for the pixel information. There are two solutions for resolving the performance bottleneck. The first solution is to apply alpha blending to surfaces allocated in system memory and then copy the completed image into video memory. Thus the PCI bus is only used for large block transfers to video memory. If the surfaces must remain in video memory then all requests for pixel information on video surfaces should be cached. For example, the first request for a pixel from a video surface should read multiple bytes into a temporary storage location in system memory, while subsequent access to the video surface is directed to the cache area.
The MMX Technology implementation takes advantage of work reduction and integer calculations to create resulting alpha blended pixel map. The SIMD instructions read in four values from the alpha stream to determine if the four runs of pixels require alpha blending. For pixel runs that require alpha blending the integer equation is applied to the source and destination pixel streams. The MMX Technology data flow is shown in Figure 5 for the green component implementation in the five bit alpha blending algorithm. This is an exact replication of the integer equation shown in Figure 3.
Figure 5: MMX Technology Data Flow for Green Component Alpha
Blend
The following test results were obtained from a prototype 233MHz Pentium II using system memory blocks ranging from 2k to 64k in size. Both source and destination surfaces were allocated the same sized memory blocks. The source was zero filled and the destination was filled by the maximum pixel value (0x7FFF for 555 pixels and 0xFFFF for 565 pixels). The eight bit alpha values used in the calculations were randomly generated. The two routines, 565 and 555 alpha blending, generated very similar test results. Therefore the results of both routines were approximated to generate a combined MMX Technology result versus scalar assembly performance shown in Figure 6. The performance of the MMX Technology routines were between four to five times faster than the scalar assembly routine. For small pixel runs the benefits of MMX Technology is minor compared to scalar assembly because of the data setup overhead for alpha blend values and pixel component manipulation. With larger runs of pixels the benefits of work reduction and SIMD shows in the cases of 8K to 64K block which translate to sixteen bit pixel blocks of 64x64 to 256x128.
Figure 6: Alpha Blending Vs. Memory Block Size on a Pentium II
Processor
16-bit alpha blending routine with an 8-bit mask produces a performance boost on the Pentium II processor when the optimizations discussed in Section 2.2 are implemented. This was shown in Section 3.0, where the performance boost was between four to five times faster than the equivalent assembly routine. MMXTM Technology was the primary contributor to the speed increase by processing four pixels per loop iteration. However the Pentium II Processor eased code implementation by dispensing the need for pairing instructions (by using dynamic execution) and aligned cache line accesses for surfaces in system memory. The combinatory effect is an algorithm that is significantly faster than its scalar assembly counterpart.
/*Alpha blending routine for 555 video hardware
lpAlpha=Pointer to location of 8-bit alpha mask
iAlpPitch=The span of a row in the alpha mask
lpSrc=Pointer to location of 16-bit 555 source bitmap
iSrcX=Starting X location of 16-bit source bitmap
iSrcY=Starting Y location of 16-bit source bitmap
iSrcPitch=The span of a row of pixels in the Source bitmap
lpDst=Pointer to location of 16-bit 555 destination bitmap
iDstX=Starting X location of 16-bit destination bitmap
iDstY=Starting Y location of 16-bit destination bitmap
iDstW=Width in pixels for alpha mask, source and destination bitmaps
iDstH=Height in pixels for alpha mask, source and destination bitmaps
iDstPitch=The span of a row of pixels in the destination bitmap*/
void ablend_555(unsigned char *lpAlpha,unsigned int iAlpPitch,
unsigned char *lpSrc,unsigned int iSrcX, unsigned int iSrcY,
unsigned int iSrcPitch, unsigned char *lpDst,
unsigned int iDstX, unsigned int iDstY,
unsigned int iDstW, unsigned int iDstH,
unsigned int iDstPitch)
{
//Mask for isolating the red,green, and blue components
static __int64 MASKR=0x001F001F001F001F;
static __int64 MASKG=0x03E003E003E003E0;
static __int64 MASKB=0x7C007C007C007C00;
//constants used by the integer alpha blending equation
static __int64 SIXTEEN=0x0010001000100010;
static __int64 FIVETWELVE=0x0200020002000200;
pointer for linear destination
unsigned char *lpLinearDstBp=(iDstX<<1)+(iDstY*iDstPitch)+lpDst; //base for linear source
pointer unsigned char *lpLinearSrcBp=(iSrcX<<1)+(iSrcY*iSrcPitch)+lpSrc; //base linear alpha
for unsigned char *lpLinearAlpBp=iSrcX+(iSrcY*iAlpPitch)+lpAlpha; //base pointer
_asm{
mov esi,lpLinearSrcBp; //src
mov edi,lpLinearDstBp; //dst
mov eax,lpLinearAlpBp; //alpha
mov ecx,iDstH; //ecx=number of lines to copy
mov ebx,iDstW; //ebx=span width to copy
test esi,6; //check if source address is qword aligned
//since addr coming in is always word aligned(16bit)
jnz done; //if not qword aligned we don't do anything
primeloop:
movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0
pxor mm2,mm2; //mm2=2;
movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0
punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0
loopqword:
mov edx,[eax];
test ebx,0xFFFFFFFC; //check if only 3 pixels left
jz checkback; //3 or less pixels left
//early out tests
cmp edx,0xffffffff; //test for alpha value of 1
je copyback; //if 1's copy the source pixels to the destination
test edx,0xffffffff; //test for alpha value of 0
jz leavefront; //if so go to the next 4 pixels
//the alpha blend starts
//i=a*sr+(31-a)*dr;
//i=(i+16)+((i+16)>>5)>>5;
movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0
psrlw mm1,3; //mm1=a?>>3 nuke out lower 3 bits
movq mm7,MASKG; //g3: mm7=green mask
movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0
movq mm2,MASKR; //g4: mm2=31
pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0
psubsb mm2,mm0; //g6: mm2=31-a3 31-a2 31-a1 31-a0
pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0
movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0
pmullw mm4,mm1; //g8: mm4=sg?*a?
movq mm7,MASKR; //b2: mm7=blue mask
pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)
movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0
pand mm3,mm7; //b4: mm3=sb3 sb2 sb1 sb0
pand mm0,mm7; //b5: mm0=db3 db2 db1 db0
pmullw mm3,mm1; //b6: mm3=sb?*a?
movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0
paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)
paddw mm4,FIVETWELVE; //g11: mm4=(mm4+512) green
pmullw mm0,mm2; //b7: mm0=db?*(1-a?)
pand mm7,MASKB; //r2: mm7=sr3 sr2 sr1 sr0
movq mm5,mm4; //g12: mm5=mm4 green
psrlw mm4,5; //g13: mm4=mm4>>5
paddw mm4,mm5; //g14: mm4=mm5+mm4 green
movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0
paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)
paddw mm0,SIXTEEN; //b9: mm0=(mm0+16) blue
psrlw mm7,10; //r4: shift src red down to position 0
pand mm5,MASKB; //r5: mm5=dr3 dr2 dr1 dr0
psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green
movq mm3,mm0; //b10: mm3=mm0 blue
psrlw mm0,5; //b11: mm0=mm0>>5 blue
psrlw mm5,10; //r6: shift dst red down to position 0
paddw mm0,mm3; //b12: mm0=mm3+mm0 blue
psrlw mm0,5; //b13: mm0=000b 000b 000b 000b blue
pmullw mm7,mm1; //mm7=sr?*a?
pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green
pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)
por mm0,mm4; //mm0=00gb 00gb 00gb 00gb
add eax,4; //move to next 4 alphas
add esi,8; //move to next 4 pixels in src
add edi,8; //move to next 4 pixels in dst
movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0
paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)
paddw mm5,SIXTEEN; //r9: mm5=(mm5+16) red
pxor mm2,mm2; //mm0=0;
movq mm7,mm5; //r10: mm7=mm5 red
psrlw mm5,5; //r11: mm5=mm5>>5 red
movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0
paddw mm5,mm7; //r12: mm5=mm7+mm5 red
punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0
psrlw mm5,5; //r13: mm5=mm5>>5 red
psllw mm5,10; //r14: mm5=mm5<<10 red
por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb
sub ebx,4; //polished off 4 pixels
movq [edi-8],mm0; //dst=0rgb 0rgb 0rgb 0rgb
jmp loopqword; //go back to start
copyback:
movq [edi],mm4; //copy source to destination
leavefront:
add edi,8; //advance destination by 4 pixels
add eax,4; //advance alpha by 4
add esi,8; //advance source by 4 pixels
sub ebx,4; //decrease pixel count by 4
jmp primeloop;
checkback:
test ebx,0xFF; //check if 0 pixels left
jz nextline; //done with this span
//backalign: //work out back end pixels
movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0
psrlw mm1,3; //mm1=a?>>3 nuke out lower 3 bits
movq mm7,MASKG; //g3: mm7=green mask
movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0
movq mm2,MASKR; //g4: mm2=31 mask
pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0
psubsb mm2,mm0; //g6: mm2=31-a3 31-a2 31-a1 31-a0
pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0
movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0
pmullw mm4,mm1; //g8: mm4=sg?*a?
movq mm7,MASKR; //b2: mm7=blue mask
pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)
movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0
pand mm3,mm7; //b4: mm3=sb3 sb2 sb1 sb0
pand mm0,mm7; //b5: mm0=db3 db2 db1 db0
pmullw mm3,mm1; //b6: mm3=sb?*a?
movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0
paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)
paddw mm4,FIVETWELVE; //g11: mm4=(mm4+512) green
pmullw mm0,mm2; //b7: mm0=db?*(1-a?)
pand mm7,MASKB; //r2: mm7=sr3 sr2 sr1 sr0
movq mm5,mm4; //g12: mm5=mm4 green
psrlw mm4,5; //g13: mm4=mm4>>5
paddw mm4,mm5; //g14: mm4=mm4+mm5 green
movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0
paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)
paddw mm0,SIXTEEN; //b9: mm0=mm0 blue
psrlw mm7,10; //r4: shift src red down to position 0
pand mm5,MASKB; //r5: mm5=dr3 dr2 dr1 dr0
psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green
movq mm3,mm0; //b10: mm3=mm0 blue
psrlw mm0,5; //b11: mm0=mm0>>5 blue
psrlw mm5,10; //r6: shift dst red down to position 0
paddw mm0,mm3; //b12: mm0=mm0+mm3 blue
psrlw mm0,5; //b13: mm0=000b 000b 000b 000b blue
pmullw mm7,mm1; //mm7=sr?*a?
pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green
pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)
por mm0,mm4; //mm0=00gb 00gb 00gb 00gb
//stall
paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)
paddw mm5,SIXTEEN; //r9: mm5=mm5 red
movq mm7,mm5; //r10: mm7=mm5 red
psrlw mm5,5; //r11: mm5=mm5>>5 red
paddw mm5,mm7; //r12: mm5=mm5+mm7 red
psrlw mm5,5; //r13: mm5=mm5>>5 red
psllw mm5,10; //r14: mm5=mm5<<10 red
por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb
test ebx,2; //check if there are 2 pixels
jz oneendpixel; //goto one pixel if that's it
movd [edi],mm0; //dst=0000 0000 0rgb 0rgb
psrlq mm0,32; //mm0>>32
add edi,4; //edi=edi+4
sub ebx,2; //saved 2 pixels
jz nextline; //all done goto next line
oneendpixel: //work on last pixel
movd edx,mm0; //edx=0rgb
mov [edi],dx; //dst=0rgb
nextline: //goto next line
dec ecx; //nuke one line
jz done; //all done
mov eax,lpLinearAlpBp; //alpha
mov esi,lpLinearSrcBp; //src
mov edi,lpLinearDstBp; //dst
add eax,iAlpPitch; //inc alpha ptr by 1 line
add esi,iSrcPitch; //inc src ptr by 1 line
add edi,iDstPitch; //inc dst ptr by 1 line
mov lpLinearAlpBp,eax; //save new alpha base ptr
mov ebx,iDstW; //ebx=span width to copy
mov lpLinearSrcBp,esi; //save new src base ptr
mov lpLinearDstBp,edi; //save new dst base ptr
jmp primeloop; //start the next span
done:
emms
}
}
/*Alpha blending routine for 565 video hardware
lpAlpha=Pointer to location of 8-bit alpha mask
iAlpPitch=The span of a row in the alpha mask
lpSrc=Pointer to location of 16-bit 565 source bitmap
iSrcX=Starting X location of 16-bit source bitmap
iSrcY=Starting Y location of 16-bit source bitmap
iSrcPitch=The span of a row of pixels in the Source bitmap
lpDst=Pointer to location of 16-bit 565 destination bitmap
iDstX=Starting X location of 16-bit destination bitmap
iDstY=Starting Y location of 16-bit destination bitmap
iDstW=Width in pixels for alpha mask, source and destination bitmaps
iDstH=Height in pixels for alpha mask, source and destination bitmaps
iDstPitch=The span of a row of pixels in the destination bitmap*/
void ablend_565(unsigned char *lpAlpha,unsigned int iAlpPitch,
unsigned char *lpSrc,unsigned int iSrcX, unsigned int iSrcY,
unsigned int iSrcPitch, unsigned char *lpDst,
unsigned int iDstX, unsigned int iDstY,
unsigned int iDstW, unsigned int iDstH,
unsigned int iDstPitch)
{
//Mask for isolating the red,green, and blue components
static __int64 MASKB=0x001F001F001F001F;
static __int64 MASKG=0x07E007E007E007E0;
static __int64 MASKSHIFTG=0x03F003F003F003F0;
static __int64 MASKR=0xF800F800F800F800;
//constants used by the integer alpha blending equation
static __int64 SIXTEEN=0x0010001000100010;
static __int64 FIVETWELVE=0x0200020002000200;
static __int64 SIXONES=0x003F003F003F003F;
unsigned char *lpLinearDstBp=(iDstX<<1)+(iDstY*iDstPitch)+lpDst; //base pointer for linear destination
unsigned char *lpLinearSrcBp=(iSrcX<<1)+(iSrcY*iSrcPitch)+lpSrc; //base pointer for linear source
unsigned char *lpLinearAlpBp=iSrcX+(iSrcY*iAlpPitch)+lpAlpha; //base pointer for linear alpha
_asm{
mov esi,lpLinearSrcBp; //src
mov edi,lpLinearDstBp; //dst
mov eax,lpLinearAlpBp; //alpha
mov ecx,iDstH; //ecx=number of lines to copy
mov ebx,iDstW; //ebx=span width to copy
test esi,6; //check if source address is qword aligned
//since addr coming in is always word aligned(16bit)
jnz done; //if not qword aligned we don't do anything
primeloop:
movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0
pxor mm2,mm2; //mm2=0;
movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0
punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0
loopqword:
mov edx,[eax];
test ebx,0xFFFFFFFC; //check if only 3 pixels left
jz checkback; //3 or less pixels left
//early out tests
cmp edx,0xffffffff; //test for alpha value of 1
je copyback; //if 1's copy the source pixels to the destination
test edx,0xffffffff; //test for alpha value of 0
jz leavefront; //if so go to the next 4 pixels
//the alpha blend starts
//green
//i=a*sg+(63-a)*dg;
//i=(i+32)+((i+32)>>6)>>6;
//red
//i=a*sr+(31-a)*dr;
//i=(i+16)+((i+16)>>5)>>5;
movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0
psrlw mm1,2; //mm1=a?>>2 nuke out lower 2 bits
movq mm7,MASKSHIFTG; //g3: mm7=1 bit shifted green mask
psrlw mm4,1; //g3a: move src green down by 1 so that we won't overflow
movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0
psrlw mm5,1; //g3b: move dst green down by 1 so that we won't overflow
psrlw mm1,1; //mm1=a?>>1 nuke out lower 1 bits
pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0
movq mm2,SIXONES;//g4: mm2=63
pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0
movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0
psubsb mm2,mm0; //g6: mm2=63-a3 63-a2 63-a1 63-a0
movq mm7,MASKB; //b2: mm7=BLUE MASK
pmullw mm4,mm0; //g8: mm4=sg?*a?
movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0
pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)
movq mm2,mm7; //b4: mm2=fiveones
pand mm3,mm7; //b4: mm3=sb3 sb2 sb1 sb0
pmullw mm3,mm1; //b6: mm3=sb?*a?
pand mm0,mm7; //b5: mm0=db3 db2 db1 db0
movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0
paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)
pand mm7,MASKR; //r2: mm7=sr3 sr2 sr1 sr0
psubsb mm2,mm1; //b5a: mm2=31-a3 31-a2 31-a1 31-a0
paddw mm4,FIVETWELVE; //g11: mm4=(mm4+512) green
pmullw mm0,mm2; //b7: mm0=db?*(1-a?)
movq mm5,mm4; //g12: mm5=mm4 green
psrlw mm7,11; //r4: shift src red down to position 0
psrlw mm4,6; //g13: mm4=mm4>>6
paddw mm4,mm5; //g14: mm4=mm4+mm5 green
paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)
movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0
paddw mm0,SIXTEEN; //b9: mm0=(mm0+16) blue
pand mm5,MASKR; //r5: mm5=dr3 dr2 dr1 dr0
psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green
movq mm3,mm0; //b10: mm3=mm0 blue
psrlw mm0,5; //b11: mm0=mm0>>5 blue
psrlw mm5,11; //r6: shift dst red down to position 0
paddw mm0,mm3; //b12: mm0=mm3+mm0 blue
psrlw mm0,5; //b13: mm0=000b 000b 000b 000b blue
pmullw mm7,mm1; //mm7=sr?*a?
pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green
pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)
por mm0,mm4; //mm0=00gb 00gb 00gb 00gb
add eax,4; //move to next 4 alphas
add esi,8; //move to next 4 pixels in src
add edi,8; //move to next 4 pixels in dst
movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0
paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)
paddw mm5,SIXTEEN; //r9: mm5=(mm5+16) red
pxor mm2,mm2; //mm2=0;
movq mm7,mm5; //r10: mm7=mm5 red
psrlw mm5,5; //r11: mm5=mm5>>5 red
movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0
paddw mm5,mm7; //r12: mm5=mm7+mm5 red
punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0
psrlw mm5,5; //r13: mm5=mm5>>5 red
psllw mm5,11; //r14: mm5=mm5<<10 red
por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb
sub ebx,4; //polished off 4 pixels
movq [edi-8],mm0; //dst=0rgb 0rgb 0rgb 0rgb
jmp loopqword; //go back to start
copyback:
movq [edi],mm4; //copy source to destination
leavefront:
add edi,8; //advance destination by 4 pixels
add eax,4; //advance alpha by 4
add esi,8; //advance source by 4 pixels
sub ebx,4; //decrease pixel count by 4
jmp primeloop;
checkback:
test ebx,0xFF; //check if 0 pixels left
jz nextline; //done with this span
//backalign: //work out back end pixels
movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0
psrlw mm1,2; //mm1=a?>>2 nuke out lower 2 bits
movq mm7,MASKSHIFTG; //g3: mm7=shift 1 bit green mask
psrlw mm4,1; //g3a: move src green down by 1 so that we won't overflow
movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0
psrlw mm5,1; //g3b: move dst green down by 1 so that we won't overflow
psrlw mm1,1; //mm1=a?>>1 nuke out lower 1 bits
pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0
movq mm2,SIXONES;//g4: mm2=63
pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0
movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0
psubsb mm2,mm0; //g6: mm2=63-a3 63-a2 63-a1 63-a0
movq mm7,MASKB; //b2: mm7=BLUE MASK
pmullw mm4,mm0; //g8: mm4=sg?*a?
movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0
pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)
movq mm2,mm7; //b4: mm2=fiveones
pand mm3,mm7; //b4: mm3=sr3 sr2 sr1 sr0
pmullw mm3,mm1; //b6: mm3=sb?*a?
pand mm0,mm7; //b5: mm0=db3 db2 db1 db0
movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0
paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)
pand mm7,MASKR; //r2: mm7=sr3 sr2 sr1 sr0
psubsb mm2,mm1; //b5a: mm2=31-a3 31-a2 31-a1 31-a0
paddw mm4,FIVETWELVE; //g11: mm4=(i+512) green
pmullw mm0,mm2; //b7: mm0=db?*(1-a?)
movq mm5,mm4; //g12: mm5=(i+512) green
psrlw mm7,11; //r4: shift src red down to position 0
psrlw mm4,6; //g13: mm4=(i+512)>>6
paddw mm4,mm5; //g14: mm4=(i+512)+((i+512)>>6) green
paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)
movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0
paddw mm0,SIXTEEN; //b9: mm0=(i+16) blue
pand mm5,MASKR; //r5: mm5=dr3 dr2 dr1 dr0
psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green
movq mm3,mm0; //b10: mm3=(i+16) blue
psrlw mm0,5; //b11: mm0=(i+16)>>5 blue
psrlw mm5,11; //r6: shift dst red down to position 0
paddw mm0,mm3; //b12: mm0=(i+16)+(i+16)>>5 blue
psrlw mm0,5; //b13: mm0=000r 000r 000r 000r blue
pmullw mm7,mm1; //mm7=sr?*a?
pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green
pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)
por mm0,mm4; //mm0=00gb 00gb 00gb 00gb
add eax,4; //move to next 4 alphas
//stall
paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)
paddw mm5,SIXTEEN; //r9: mm5=(i+16) red
movq mm7,mm5; //r10: mm7=(i+16) red
psrlw mm5,5; //r11: mm5=(i+16)>>5 red
paddw mm5,mm7; //r12: mm5=(i+16)+((i+16)>>5) red
psrlw mm5,5; //r13: mm5=(i+16)+((i+16)>>5)>>5 red
psllw mm5,11; //r14: mm5=mm5<<10 red
por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb
test ebx,2; //check if there are 2 pixels
jz oneendpixel; //goto one pixel if that's it
movd [edi],mm0; //dst=0000 0000 0rgb 0rgb
psrlq mm0,32; //mm0>>32
add edi,4; //edi=edi+4
sub ebx,2; //saved 2 pixels
jz nextline; //all done goto next line
oneendpixel: //work on last pixel
movd edx,mm0; //edx=0rgb
mov [edi],dx; //dst=0rgb
nextline: //goto next line
dec ecx; //nuke one line
jz done; //all done
mov eax,lpLinearAlpBp; //alpha
mov esi,lpLinearSrcBp; //src
mov edi,lpLinearDstBp; //dst
add eax,iAlpPitch; //inc alpha ptr by 1 line
add esi,iSrcPitch; //inc src ptr by 1 line
add edi,iDstPitch; //inc dst ptr by 1 line
mov lpLinearAlpBp,eax; //save new alpha base ptr
mov ebx,iDstW; //ebx=span width to copy
mov lpLinearSrcBp,esi; //save new src base ptr
mov lpLinearDstBp,edi; //save new dst base ptr
jmp primeloop; //start the next span
done:
emms
}
}