windows-server-2003/multimedia/directx/dxg/d3d/dx6/rast/mmxspan/texread.mh

; Names are read LSB to MSB, so B5G6R5 means five bits of blue starting
; at the LSB, then six bits of green, then five bits of red.
dnl
dnl     Texture read routine have texture address passed as edi.  The offset into that
dnl     is passed as eax.  Output is mm1 in 8.8 for each color channel. For border
dnl     mm0 is used to pass sign information of iU and iV.  Each word contains a
dnl     UV pair so that all 4 values for bilinear can be stored in mm0.
dnl
dnl     The only free registers are MM1 and MM2.  EAX is free after texture is read and
dnl     edx is free after DoBorder macro.  Any other register useage will cause problems
dnl     and even exceptions.
dnl
dnl

define(`texreadVars', `
EXTERN MaskRed565to888:MMWORD
EXTERN MaskGreen565to888:MMWORD
EXTERN MaskBlue565to888:MMWORD

EXTERN MaskRed555to888:MMWORD
EXTERN MaskGreen555to888:MMWORD
EXTERN MaskBlue555to888:MMWORD

EXTERN MaskAlpha1555to8888:MMWORD
EXTERN MaskRed1555to8888:MMWORD
EXTERN MaskGreen1555to8888:MMWORD
EXTERN MaskBlue1555to8888:MMWORD

; TBD. I think that I want to do 0xffff instead of 0xff.  This will
; have to be checked.  There is a value very similiar to this in
; buf write.
EXTERN SetAlphato0xffff:MMWORD
EXTERN SetAlphato0xff:MMWORD

; TODO This equate are identical to the ones in texread.mas.  Maybe they should be in a common .inc file.
RedShift565to888     equ 8
GreenShift565to888   equ 5
BlueShift565to888    equ 3

RedShift555to888     equ 9
GreenShift555to888   equ 6
BlueShift555to888    equ 3

AlphaShift1555to8888 equ 16
RedShift1555to8888   equ 9
GreenShift1555to8888 equ 6
BlueShift1555to8888  equ 3

EXTERN Zero:MMWORD
')

dnl
dnl d_DoTex
dnl
dnl Calls the macro in $1 with all options to generate differentiated texture
dnl read functions.  Specifies that all of these are Not Monolithic.
dnl Monolithic cases will need to call routines by themselves and specify border and colorkey options.
dnl
define(`d_DoTex', `d_Null($1(NoBorder, NoColorKey, NotMonolithic))
d_Null($1(NoBorder, ColorKey, NotMonolithic))
d_Null($1(Border, NoColorKey, NotMonolithic))
d_Null($1(Border, ColorKey, NotMonolithic))')dnl
dnl
dnl d_DoBorder
dnl
dnl Inserts conditional border code
dnl
define(`d_DoBorder', `ifelse(`$1', `NoBorder', `
; Generate Border Mask to always be true in non border case.
    ;pcmpeqd mm5, mm5
', `
    ; Generate Border Mask based on if statement.
    ;if ((iU < 0) || (iV < 0))
    ;{
    ; Are branches bad enough to do all of this code?
    ; Address ends up negative when were supposed to set the border color.
    ; Generate mask based on sign bit.
    movq    mm5, mm0
    psrlq   mm0, 16 ; Shift iu iv values for next border case. This is only useful in bilinear

    pand    mm5, MMWORD PTR CheckLowTwo8BitSignbits
    pcmpeqd mm5, MMWORD PTR Zero

    movd    edx, mm5
    and     eax, edx
        ;return pTex->BorderColor;
    ;}
')
')dnl

dnl
dnl d_DoBorderMix
dnl
dnl Inserts conditional border code
dnl
define(`d_DoBorderMix', `ifelse(`$1', `NoBorder', `
; Generate Border Mask to always be true.
    ;pcmpeqd mm5, mm5
', `
    movd    mm2, XpTex(BorderColor)
    pand    mm1, mm5
    pandn   mm5, mm2
    por     mm1, mm5
')
')dnl
dnl
dnl d_DoColorKey
dnl
dnl Inserts conditional color key code
dnl $1 the function type, $2 is the thing to test against the Transparent color,
dnl and $3 is its type.
dnl
define(`d_DoColorKey', `ifelse(`$1', `ColorKey', `
; Generate another mask based on TransparentColor
; Should be able to do pcmpeq to generate mask.
; Need Palettized and non Palettized code both use eax for the original Texel.
;    if (ColorOriTexel == (int32)pTex->TransparentColor)
;    {
;        Color &= 0xffffff;
;    }
    movq        mm2, mm1
    movd        mm1, eax
    pcmpeqd     mm1, XpTex(TransparentColor)
                            ; if they are equal then mm1 = 0xffffffff else mm1 = 0
    pslld       mm1, 24     ; mm1 = 0xffffffff << 24 = 0xff000000 or mm2 = 0 << 24 = 0.
    pandn       mm1, mm2    ; mask off alpha if color is transparent color.

')')dnl
dnl

dnl
dnl d_DoReturn
dnl
dnl Inserts conditional return.  Return in general case and dont in monolith case.
dnl
define(`d_DoReturn', `ifelse(`$1', `NotMonolithic', `
    ;return Color;
    ret
', `
    ; No call or return in monolith case.
')
')dnl

define(`d_Palette8', ``
; This code needs to be cleaned up quite a bit.
;D3DCOLOR TexRead_Palette8_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_Palette8_$1_$2
_MMX_TexRead_Palette8_$1_$2:
')
    ; Start this line now to give pmadd moretime to finish
    ; INT32 iTexel = pBits[iU | (iV << iShiftU)];
    ; Save mm3 for now
    ; TBD look to see if need to save it or if it will change.

d_DoBorder(`$1')

    movzx   eax, byte ptr [edi + eax]   ; get index
    mov     edx, eax
    shl     edx, 2                      ; convert to DWORD offset
    ;D3DCOLOR Color = pTex->pPalette[iTexel];
    add     edx, XpTex(pPalette)  ; add index to get palette address

    movd        mm1, dword ptr[edx]
    movq        mm2, mm1                        ; 0000?BGR = mm2
    punpcklwd   mm1, mm1                        ; ?B?BGRGR = mm1
    psrlq       mm2, 16                         ; 000000?B
    pand        mm2, MMWORD PTR Val0x00ff00ff   ; 0000000B
    pand        mm1, MMWORD PTR Val0xffff00     ; 00000RG0
    por         mm1, mm2                        ; 00000RGB

    ; RL palette is BGR - flip the channels into RGB
    ;Color = RGBA_MAKE((Color & 0xff),
    ;            (Color >> 8) & 0xff,
    ;            (Color >> 16) & 0xff,
    ;            0xff);

    ; result should be in mm1 for color key and border masking.
    por     mm1, dword ptr SetAlphaTo0xFF

d_DoColorKey(`$2')
d_DoBorderMix($1)

    ; Need to unpack color for bilinear 16 bit multiplications
    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl


define(`d_Palette4', ``
;D3DCOLOR TexRead_Palette4_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_Palette4_$1_$2
_MMX_TexRead_Palette4_$1_$2:
')

d_DoBorder(`$1')
    ;INT32 iIndex = iU | (iV << iShiftU);

    ; Need ecx to shift with.  Save it off since it will be needed later.
    mov     edx, ecx

    mov     ecx, eax
    and     ecx, 1

    ;INT32 iTexel = pBits[iIndex>>1];
    shr     eax, 1
    movzx   eax, byte ptr [edi + eax]   ; get index

    ;if ((iIndex & 1) == 0)
    ;{
    ;    iTexel &= 0xf;
    ;}
    ;else
    ;{
    ;    iTexel >>= 4;
    ;}
    shl     ecx, 2  ; This will make ecx 0 or 4.  This gets lookup value in correct place without branching.
    shr     eax, cl ; Shift by 0 or 4 now.
    and     eax, 0fh
    mov     ecx, eax

    shl     ecx, 2                      ; convert to DWORD offset

    ;D3DCOLOR Color = pTex->pPalette[iTexel];
    add         ecx, XpTex(pPalette)  ; add index to get palette address
    movd        mm1, dword ptr[ecx]

    ; RL palette is BGR - flip the channels into RGB
    ;Color = RGBA_MAKE((Color & 0xff),
    ;            (Color >> 8) & 0xff,
    ;            (Color >> 16) & 0xff,
    ;            0xff);
    movq        mm2, mm1                        ; 0000?BGR = mm2
    punpcklwd   mm1, mm1                        ; ?B?BGRGR = mm1
    psrlq       mm2, 16                         ; 000000?B
    pand        mm2, MMWORD PTR Val0x00ff00ff   ; 0000000B
    pand        mm1, MMWORD PTR Val0xffff00     ; 00000RG0
    por         mm1, mm2                        ; 00000RGB

    por     mm1, dword ptr SetAlphaTo0xFF

d_DoColorKey(`$2')
d_DoBorderMix($1)

    punpcklbw mm1, MMWORD PTR Zero

    ; Revive ecx.
    mov     ecx, edx

d_DoReturn($3)

;}'')dnl

define(`d_Palette8A', ``
; This code needs to be cleaned up quite a bit.
;D3DCOLOR TexRead_Palette8A_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_Palette8A_$1_$2
_MMX_TexRead_Palette8A_$1_$2:
')
    ; Start this line now to give pmadd moretime to finish
    ; INT32 iTexel = pBits[iU | (iV << iShiftU)];
    ; Save mm3 for now
    ; TBD look to see if need to save it or if it will change.

d_DoBorder(`$1')

    movzx   eax, byte ptr [edi + eax]   ; get index
    mov     edx, eax
    shl     edx, 2                      ; convert to DWORD offset
    ;D3DCOLOR Color = pTex->pPalette[iTexel];
    add     edx, XpTex(pPalette)  ; add index to get palette address

    movd        mm1, dword ptr[edx]
    movq        mm2, mm1                        ; 0000ABGR = mm2
    pand        mm1, MMWORD PTR Val0xff00ff00   ; 0000A0G0 = mm1
    pand        mm2, MMWORD PTR Val0x00ff00ff   ; 00000B0R = mm2
    psllq       mm2, 16                         ; 000B0R00 = mm2
    por         mm1, mm2                        ; 000BARG0 = mm1
    psrlq       mm2, 32                         ; 0000000B = mm2
    por         mm1, mm2                        ; 000BARBG = mm1

    ; RL palette is BGR - flip the channels into RGB
    ;Color = RGBA_MAKE((Color & 0xff),
    ;            (Color >> 8) & 0xff,
    ;            (Color >> 16) & 0xff,
    ;            (Color >> 24) & 0xff);

d_DoColorKey(`$2')
d_DoBorderMix($1)

    ; Need to unpack color for bilinear 16 bit multiplications
    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl

define(`d_Palette4A', ``
;D3DCOLOR TexRead_Palette4A_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_Palette4A_$1_$2
_MMX_TexRead_Palette4A_$1_$2:
')

d_DoBorder(`$1')
    ;INT32 iIndex = iU | (iV << iShiftU);

    ; Need ecx to shift with.  Save it off since it will be needed later.
    mov     edx, ecx

    mov     ecx, eax
    and     ecx, 1

    ;INT32 iTexel = pBits[iIndex>>1];
    shr     eax, 1
    movzx   eax, byte ptr [edi + eax]   ; get index

    ;if ((iIndex & 1) == 0)
    ;{
    ;    iTexel &= 0xf;
    ;}
    ;else
    ;{
    ;    iTexel >>= 4;
    ;}
    shl     ecx, 2  ; This will make ecx 0 or 4.  This gets lookup value in correct place without branching.
    shr     eax, cl ; Shift by 0 or 4 now.
    and     eax, 0fh
    mov     ecx, eax

    shl     ecx, 2                      ; convert to DWORD offset

    ;D3DCOLOR Color = pTex->pPalette[iTexel];
    add         ecx, XpTex(pPalette)  ; add index to get palette address
    movd        mm1, dword ptr[ecx]

    ; RL palette is BGR - flip the channels into RGB
    ;Color = RGBA_MAKE((Color & 0xff),
    ;            (Color >> 8) & 0xff,
    ;            (Color >> 16) & 0xff,
    ;            (Color >> 24) & 0xff);
    movq        mm2, mm1                        ; 0000ABGR = mm2
    pand        mm1, MMWORD PTR Val0xff00ff00   ; 0000A0G0 = mm1
    pand        mm2, MMWORD PTR Val0x00ff00ff   ; 00000B0R = mm2
    psllq       mm2, 16                         ; 000B0R00 = mm2
    por         mm1, mm2                        ; 000BARG0 = mm1
    psrlq       mm2, 32                         ; 0000000B = mm2
    por         mm1, mm2                        ; 000BARBG = mm1


d_DoColorKey(`$2')
d_DoBorderMix($1)

    punpcklbw mm1, MMWORD PTR Zero

    ; Revive ecx.
    mov     ecx, edx

d_DoReturn($3)

;}'')dnl

define(`d_B8G8R8', ``
;D3DCOLOR TexRead_B8G8R8_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_B8G8R8_$1_$2
_MMX_TexRead_B8G8R8_$1_$2:
')

d_DoBorder(`$1')

    ;D3DCOLOR Color = (((D3DCOLOR*)pBits)[iU | (iV << iShiftU)])  | 0xff000000;
    ; Save mm3 for now
    ; TBD look to see if need to save it or if it will change.
    mov     eax, dword ptr [edi+4*eax]
    movd    mm1, eax    ; save copy of original texel
    por     mm1, dword ptr SetAlphaTo0xFF

d_DoColorKey(`$2')
d_DoBorderMix($1)

    ; Need to unpack color for bilinear 16 bit multiplications
    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)
;}'')dnl

define(`d_B8G8R8A8', ``
;D3DCOLOR TexRead_B8G8R8A8_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_B8G8R8A8_$1_$2
_MMX_TexRead_B8G8R8A8_$1_$2:

')

d_DoBorder(`$1')
    ;D3DCOLOR Color = ((D3DCOLOR*)pBits)[iU | (iV << iShiftU)];
    mov     eax, dword ptr [edi+4*eax]  ; This should be aligned
    movd    mm1, eax    ; save copy of original texel

d_DoColorKey(`$2')
d_DoBorderMix($1)

    punpcklbw mm1, MMWORD PTR Zero
d_DoReturn($3)

;}'')dnl

define(`d_B5G6R5', ``
;D3DCOLOR TexRead_B5G6R5_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_B5G6R5_$1_$2
_MMX_TexRead_B5G6R5_$1_$2:
')
d_DoBorder(`$1')
    movzx   eax, word ptr [edi+2*eax]
    ;UINT16 uTexel = ((UINT16*)pBits)[iU | (iV << iShiftU)];
    ;D3DCOLOR Color = RGBA_MAKE(( uTexel >> 8 ) & 0xf8,
    ;            (( uTexel >> 3) & 0xfc ),
    ;            (( uTexel << 3) & 0xf8 ),
    ;            0xff);
    movd    mm1, eax    ; Make three more copies of input color
    mov     edx, eax
    movq    mm2, mm1

    pand    mm1, dword ptr MaskGreen565to888  ; MaskGreen565to888 is in memory
    psllq   mm2, RedShift565to888   ; RedShift should be an immediate

    pand    mm2, dword ptr MaskRed565to888    ; MaskRed565to888 in memory.
    psllq   mm1, GreenShift565to888

    shl     edx, BlueShift565to888
    por     mm1, mm2

    and     edx, dword ptr MaskBlue565to888
    movd    mm2, edx

    por     mm1, dword ptr SetAlphaTo0xFF
    por     mm1, mm2

d_DoColorKey(`$2')
d_DoBorderMix($1)

    ; Dont need to unpack here since I shift to correct location.
    ; BUG BUG this will cause a problem with the border color.
    ; Could do different shifts if border is on or not.
    ; For now, just unpack and dont shift as much.

    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl

define(`d_B5G5R5', ``
;D3DCOLOR TexRead_B5G5R5_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_B5G5R5_$1_$2
_MMX_TexRead_B5G5R5_$1_$2:
')

d_DoBorder(`$1')
    ;UINT16 uTexel = ((UINT16*)pBits)[iU | (iV << iShiftU)];
    movzx   eax, word ptr [edi+2*eax]

    ;D3DCOLOR Color = RGBA_MAKE(( uTexel >> 7 ) & 0xf8,
    ;            (( uTexel >> 2) & 0xf8 ),
    ;            (( uTexel << 3) & 0xf8 ),
    ;            0xff);
    movd    mm1, eax    ; Make three more copies of input color
    mov     edx, eax
    movq    mm2, mm1

    pand    mm1, dword ptr MaskGreen555to888  ; MaskGreen555to888 is in memory
    psllq   mm2, RedShift555to888   ; RedShift should be an immediate

    pand    mm2, dword ptr MaskRed555to888    ; MaskRed555to888 in memory.
    psllq   mm1, GreenShift555to888

    shl     edx, BlueShift555to888
    por     mm1, mm2

    and     edx, dword ptr MaskBlue555to888
    movd    mm2, edx

    por     mm1, dword ptr SetAlphaTo0xFF
    por     mm1, mm2

    por     mm1, dword ptr SetAlphaTo0xFF

d_DoColorKey(`$2')
d_DoBorderMix($1)

    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl

define(`d_B5G5R5A1', ``
;D3DCOLOR TexRead_B5G5R5A1_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
    PUBLIC _MMX_TexRead_B5G5R5A1_$1_$2
_MMX_TexRead_B5G5R5A1_$1_$2:
')

d_DoBorder(`$1')
    ;INT16 iTexel = ((INT16*)pBits)[iU | (iV << iShiftU)];
    movzx   eax, word ptr [edi+2*eax]

    ;D3DCOLOR Color = RGBA_MAKE(( iTexel >> 7 ) & 0xf8,
    ;            (( iTexel >> 2) & 0xf8 ),
    ;            (( iTexel << 3) & 0xf8 ),
    ;            (iTexel >> 15) & 0xff);
    movd    mm1, eax    ; Make two more copies of input color
    movq    mm2, mm1
    mov     edx, eax

    pand    mm1, dword ptr MaskAlpha1555to8888  ; MaskAlpha1555to8888 is in memory
    psllq   mm2, RedShift1555to8888   ; RedShift should be an immediate

    pand    mm2, dword ptr MaskRed1555to8888    ; MaskRed1555to8888 in memory.
    psllq   mm1, AlphaShift1555to8888 ; shift bit to top of dword

    psrad   mm1, 7                   ; copy bit to upper 8 bits.
    por     mm1, mm2

    movd    mm2, eax
    pslld   mm2, BlueShift1555to8888
    shl     edx, GreenShift1555to8888
    pand    mm2, MMWORD PTR MaskBlue1555to8888
    por     mm1, mm2
    and     edx, dword ptr MaskGreen1555to8888
    movd    mm2, edx
    por     mm1, mm2

d_DoColorKey(`$2')
d_DoBorderMix($1)

    punpcklbw mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl

define(`d_B4G4R4', ``
;D3DCOLOR TexRead_B4G4R4_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
  PUBLIC _MMX_TexRead_B4G4R4_$1_$2
_MMX_TexRead_B4G4R4_$1_$2:
')
d_DoBorder(`$1')
    movzx   eax, word ptr [edi+2*eax]

    ;D3DCOLOR Color = RGBA_MAKE((( iTexel >> 4 ) & 0xf0),
    ;            (( iTexel >> 0) & 0xf0 ),
    ;            (( iTexel << 4) & 0xf0 ),
    ;            0xff);
    movd    mm1, eax
    pand    mm1, MMWORD ptr MaskGreen444to888
    psrld   mm1, 4

    movd    mm2, eax
    pand    mm2, MMWORD PTR MaskRedBlue444to888

    punpcklbw  mm1, mm2    ; interleave red green and blue.

    ; Duplicate 4 bits to make 8 bits.  Also allows colors to reach full intensity and linear.
    movq    mm2, mm1
    psrld   mm2, 4
    por     mm1, mm2

    por     mm1, dword ptr SetAlphaTo0xFF   ; make alpha value one.

d_DoColorKey(`$2')
d_DoBorderMix($1)

    ; Need to unpack color for bilinear 16 bit multiplications
    punpcklbw  mm1, MMWORD PTR Zero
d_DoReturn($3)
;}'')dnl

define(`d_B4G4R4A4', ``
;D3DCOLOR TexRead_B4G4R4A4_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$3', `Monolithic', `', `
    PUBLIC _MMX_TexRead_B4G4R4A4_$1_$2
_MMX_TexRead_B4G4R4A4_$1_$2:
')

d_DoBorder(`$1')
    movzx   eax, word ptr [edi+2*eax]

    ;INT16 iAlpha = ( iTexel >> 12 ) & 0xf;
    ; Kents Idea:
    ; An alpha of 0xf becomes 0xff, 0x0 becomes 0x0, and it is monotonic.
    ; May want to apply this operation to all color channels
    ; Great Idea.
    ;D3DCOLOR Color = RGBA_MAKE((( iTexel >> 4 ) & 0xf0),
    ;            (( iTexel >> 0) & 0xf0 ),
    ;            (( iTexel << 4) & 0xf0 ),
    ;            (iAlpha << 4) | iAlpha );
    movd    mm1, eax
    pand    mm1, MMWORD PTR MaskAlphaGreen4444to8888
    psrld   mm1, 4

    movd    mm2, eax
    pand    mm2, MMWORD PTR MaskRedBlue4444to8888

    punpcklbw  mm2, mm1    ; interleave red green and blue.

    ; Duplicate 4 bits to make 8 bits.  Also allows colors to reach full intensity and linear.
    movq    mm1, mm2
    pslld   mm2, 4
    por     mm1, mm2

d_DoColorKey(`$2')
d_DoBorderMix($1)
    ; BUG BUG border needs to be unpacked.
    punpcklbw  mm1, MMWORD PTR Zero

d_DoReturn($3)
;}'')dnl

define(`d_L8', ``
;D3DCOLOR TexRead_L8_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$2', `Monolithic', `', `
    PUBLIC _MMX_TexRead_L8_$1_$2
_MMX_TexRead_L8_$1_$2:
')

d_DoBorder(`$1')

    ;UINT8 iTexel = pBits[iU | (iV << iShiftU)];
    ;D3DCOLOR Color = RGBA_MAKE(iTexel,
    ;                               iTexel,
    ;                           iTexel,
    ;                           0xff );
    movzx   eax, byte ptr [edi+eax]
    movd    mm1, eax
    punpcklbw   mm1,mm1
    punpcklwd   mm1,mm1
    por     mm1, dword ptr SetAlphaTo0xFF

d_DoColorKey(`$2')
d_DoBorderMix($1)
    ; BUG BUG border needs to be unpacked.
    punpcklbw  mm1, MMWORD PTR Zero

d_DoReturn($3)

;}'')dnl


define(`d_L8A8', ``
;D3DCOLOR TexRead_L8A8_$1_$2(INT32 iU, INT32 iV, INT32 iShiftU, PUINT8 pBits, PD3DI_SPANTEX pTex)
;{
ifelse(`$2', `Monolithic', `', `
    PUBLIC _MMX_TexRead_L8A8_$1_$2
_MMX_TexRead_L8A8_$1_$2:
')

d_DoBorder(`$1')
    ;INT16 iTexel = ((INT16*)pBits)[iU | (iV << iShiftU)];
    ;INT16 iAlpha = ( iTexel >> 8 ) & 0xff;
    ;D3DCOLOR Color = RGBA_MAKE(iTexel,
    ;                           iTexel,
    ;                           iTexel,
    ;                           iAlpha );
    movzx   eax, word ptr [edi+2*eax]

    movd    mm1, eax
    pslld   mm1, 16
    and     eax, dword ptr MaskL8A8ALPHA
    movd    mm2, eax
    por     mm1, mm2
    pslld   mm2, 8
    por     mm1, mm2

d_DoColorKey(`$2')
d_DoBorderMix($1)
    ; BUG BUG border needs to be unpacked.
    punpcklbw  mm1, MMWORD PTR Zero
d_DoReturn($3)

;}'')dnl