archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/enduser/netmeeting/av/codecs/intel/h263/i386/cxm12162.asm

687 lines
24 KiB
Raw Blame History

;-------------------------------------------------------------------------
; INTEL Corporation Proprietary Information
;
; This listing is supplied under the terms of a license
; agreement with INTEL Corporation and may not be copied
; nor disclosed except in accordance with the terms of
; that agreement.
;
; Copyright (c) 1996 Intel Corporation.
; All Rights Reserved.
;
;-------------------------------------------------------------------------
;-------------------------------------------------------------------------
;//
;// $Header: S:\h26x\src\dec\cxm12162.asv
;//
;// $Log: S:\h26x\src\dec\cxm12162.asv $
;//
;// Rev 1.10 01 Apr 1997 12:51:50 BNICKERS
;// Fix bugs # 153 and 156 -- wrong color when U is small; right edge flickeri
;//
;// Rev 1.9 09 Dec 1996 15:20:40 BECHOLS
;// Brian fixed ARC bug #94.
;//
;// Rev 1.8 06 Sep 1996 16:07:58 BNICKERS
;// Re-written to filter new points.
;//
;-------------------------------------------------------------------------
;
; +---------- Color convertor.
; |+--------- For both H261 and H263.
; ||+-------- Version for Intel Microprocessors with MMX Technology
; |||++------ Convert from YUV12.
; |||||++---- Convert to RGB16.
; |||||||+--- Zoom by two.
; ||||||||
; cxm12162 -- This function performs zoom-by-2 YUV12-to-RGB16 color conversion
; for H26x. It is tuned for best performance on Intel
; Microprocessors with MMX Technology. It handles any format in
; which there are three fields, the low order field being B and
; starting in bit 0, the second field being G, and the high order
; field being R. Present support for 555, 565, 655, and 644
; formats only. This version adds new rows and columns by
; averaging them with the originals to either side.
;
; The YUV12 input is planar, 8 bits per pel. The Y plane may have
; a pitch of up to 768. It may have a width less than or equal
; to the pitch. It must be QWORD aligned. Pitch and Width must
; be a multiple of eight. Height may be any amount, but must be
; a multiple of two. The U and V planes may have a different
; pitch than the Y plane, subject to the same limitations.
;
; The color convertor is non-destructive; the input Y, U, and V
; planes will not be clobbered.
OPTION PROLOGUE:None
OPTION EPILOGUE:ReturnAndRelieveEpilogueMacro
include ccinst.inc
.xlist
include iammx.inc
include memmodel.inc
.list
MMXCCDATA SEGMENT PAGE
ALIGN 16
Luma0020004000200000 LABEL DWORD
REPEAT 16
DD 0, 0
ENDM
CNT = 0
REPEAT 219
DW 0
DW (CNT*04A7FH)/00200H
DW (CNT*04A7FH)/00100H
DW (CNT*04A7FH)/00200H
CNT = CNT + 1
ENDM
REPEAT 21
DW 00000H
DW 01FFFH
DW 03FFFH
DW 01FFFH
ENDM
UContribToBandG LABEL DWORD
DW -(-128*0C83H)/00040H
DW 08000H
DW -(-127*0C83H)/00040H
DW 08000H
CNT = -126
REPEAT 253
DW -(CNT*00C83H)/00040H
DW (CNT*0408BH)/00040H
CNT = CNT + 1
ENDM
DW (127*0C83H)/00040H
DW 07FFFH
VContribToRandG LABEL DWORD
CNT = -128
REPEAT 256
DW -(CNT*01A04H)/00040H
DW (CNT*03312H)/00040H
CNT = CNT + 1
ENDM
MMXCCDATA ENDS
.CODE
ASSUME ds : FLAT
ASSUME es : FLAT
ASSUME fs : FLAT
ASSUME gs : FLAT
ASSUME ss : FLAT
; void FAR ASM_CALLTYPE YUV12ToRGB16ZoomBy2 (U8 * YPlane,
; U8 * VPlane,
; U8 * UPlane,
; UN FrameWidth,
; UN FrameHeight,
; UN YPitch,
; UN VPitch,
; UN AspectAdjustmentCount,
; U8 * ColorConvertedFrame,
; U32 DCIOffset,
; U32 CCOffsetToLine0,
; IN CCOPitch,
; IN CCType)
;
; CCOffsetToLine0 is relative to ColorConvertedFrame.
;
; due to the need for the ebp reg, these parameter declarations aren't used,
; they are here so the assembler knows how many bytes to relieve from the stack
PUBLIC MMX_YUV12ToRGB16ZoomBy2
MMX_YUV12ToRGB16ZoomBy2 proc DIST LANG AYPlane: DWORD,
AVPlane: DWORD,
AUPlane: DWORD,
AFrameWidth: DWORD,
AFrameHeight: DWORD,
AYPitch: DWORD,
AVPitch: DWORD,
AAspectAdjustmentCnt: DWORD,
AColorConvertedFrame: DWORD,
ADCIOffset: DWORD,
ACCOffsetToLine0: DWORD,
ACCOPitch: DWORD,
ACCType: DWORD
MAXWIDTH = 768
LocalFrameSize = MAXWIDTH*20+128+64
RegisterStorageSize = 16
; Arguments:
YPlane_arg = RegisterStorageSize + 4
VPlane_arg = RegisterStorageSize + 8
UPlane_arg = RegisterStorageSize + 12
FrameWidth_arg = RegisterStorageSize + 16
FrameHeight = RegisterStorageSize + 20
YPitch_arg = RegisterStorageSize + 24
ChromaPitch_arg = RegisterStorageSize + 28
AspectAdjustmentCount_arg = RegisterStorageSize + 32
ColorConvertedFrame = RegisterStorageSize + 36
DCIOffset = RegisterStorageSize + 40
CCOffsetToLine0 = RegisterStorageSize + 44
CCOPitch_arg = RegisterStorageSize + 48
CCType = RegisterStorageSize + 52
EndOfArgList = RegisterStorageSize + 56
; Locals (on local stack frame)
DitherB EQU [esp+ 0]
DitherG EQU [esp+ 8]
DitherR EQU [esp+ 16]
SelectBBits EQU [esp+ 24]
SelectGBits EQU [esp+ 32]
SelectRBits EQU [esp+ 40]
ShiftCountForB EQU [esp+ 48]
ShiftCountForG EQU [esp+ 52]
ShiftCountForR EQU [esp+ 56]
CCOCursor EQU [esp+ 60]
CCOPitch EQU [esp+MAXWIDTH*20+128+ 0]
YCursor EQU [esp+MAXWIDTH*20+128+ 4]
YLimit EQU [esp+MAXWIDTH*20+128+ 8]
YPitch EQU [esp+MAXWIDTH*20+128+12]
UCursor EQU [esp+MAXWIDTH*20+128+16]
DistanceFromUToV EQU [esp+MAXWIDTH*20+128+20]
ChromaPitch EQU [esp+MAXWIDTH*20+128+24]
AspectCount EQU [esp+MAXWIDTH*20+128+28]
AspectAdjustmentCount EQU [esp+MAXWIDTH*20+128+32]
StartIndexOfYLine EQU [esp+MAXWIDTH*20+128+36]
StashESP EQU [esp+MAXWIDTH*20+128+40]
FiltLine0 EQU [esp+ 64] ; Must be 32 byte aligned.
FiltLine1 EQU [esp+ 72]
FiltLine2 EQU [esp+ 80]
FiltLine3 EQU [esp+ 88]
HFiltLinePrev EQU [esp+ 96]
push esi
push edi
push ebp
push ebx
mov edi,esp
and esp,0FFFFF000H
sub esp,4096
mov eax,[esp]
sub esp,4096
mov eax,[esp]
sub esp,4096
mov eax,[esp]
sub esp,LocalFrameSize-12288
mov eax,[esp]
mov eax,768
sub eax,[edi+FrameWidth_arg]
imul eax,20
mov StartIndexOfYLine,eax
mov eax,[edi+YPlane_arg]
mov YCursor,eax
mov ebx,[edi+YPitch_arg]
mov YPitch,ebx
mov ecx,[edi+FrameHeight]
imul ebx,ecx
add eax,ebx
mov YLimit,eax
mov eax,[edi+UPlane_arg]
mov ebx,[edi+VPlane_arg]
mov UCursor,eax
sub ebx,eax
mov DistanceFromUToV,ebx
mov eax,[edi+ColorConvertedFrame]
add eax,[edi+DCIOffset]
add eax,[edi+CCOffsetToLine0]
mov CCOCursor,eax
mov eax,[edi+ChromaPitch_arg]
mov ChromaPitch,eax
mov eax,[edi+CCOPitch_arg]
mov CCOPitch,eax
mov eax,[edi+AspectAdjustmentCount_arg]
mov AspectAdjustmentCount,eax
mov AspectCount,eax
mov StashESP,edi
mov eax,[edi+CCType]
cmp eax,CCTYPE_RGB16555ZoomBy2
je CCTypeIs555
cmp eax,CCTYPE_RGB16555ZoomBy2DCI
je CCTypeIs555
cmp eax,CCTYPE_RGB16565ZoomBy2
je CCTypeIs565
cmp eax,CCTYPE_RGB16565ZoomBy2DCI
je CCTypeIs565
cmp eax,CCTYPE_RGB16655ZoomBy2
je CCTypeIs655
cmp eax,CCTYPE_RGB16655ZoomBy2DCI
je CCTypeIs655
cmp eax,CCTYPE_RGB16664ZoomBy2DCI
je CCTypeIs664
cmp eax,CCTYPE_RGB16664ZoomBy2
je CCTypeIs664
mov eax,0DEADBEEFH
mov YCursor,eax
CCTypeIs555:
mov eax,000000200H ; Dither pattern.
mov ebx,002000000H
mov DitherB,eax
mov DitherB+4,eax
mov DitherG,ebx
mov DitherG+4,ebx
mov DitherR,eax
mov DitherR+4,eax
mov eax,003E003E0H ; Bits to extract for fields
mov ebx,07C007C00H
mov SelectGBits,eax
mov SelectGBits+4,eax
mov SelectRBits,ebx
mov SelectRBits+4,ebx
mov eax,0001F001FH
xor ecx,ecx ; Left shift count for R
mov SelectBBits,eax
mov SelectBBits+4,eax
mov eax,10 ; Right shift count for B
mov ebx,5 ; Right shift count for G
mov ShiftCountForB,eax
mov ShiftCountForG,ebx
mov ShiftCountForR,ecx
jmp CCTypeInitialized
CCTypeIs565:
mov eax,000000200H
mov ebx,004000000H
mov DitherB,eax
mov DitherB+4,eax
mov DitherG,ebx
mov DitherG+4,ebx
mov DitherR,eax
mov DitherR+4,eax
mov eax,007E007E0H
mov ebx,0F800F800H
mov SelectGBits,eax
mov SelectGBits+4,eax
mov SelectRBits,ebx
mov SelectRBits+4,ebx
mov eax,0001F001FH
mov ecx,1
mov SelectBBits,eax
mov SelectBBits+4,eax
mov eax,10
mov ebx,4
mov ShiftCountForB,eax
mov ShiftCountForG,ebx
mov ShiftCountForR,ecx
jmp CCTypeInitialized
CCTypeIs655:
mov eax,000000200H ; Dither pattern.
mov ebx,004000000H
mov DitherB,eax
mov DitherB+4,eax
mov DitherG,eax
mov DitherG+4,eax
mov DitherR,ebx
mov DitherR+4,ebx
mov eax,003E003E0H ; Bits to extract for fields
mov ebx,0FC00FC00H
mov SelectGBits,eax
mov SelectGBits+4,eax
mov SelectRBits,ebx
mov SelectRBits+4,ebx
mov eax,0001F001FH
mov ecx,1 ; Left shift count for R
mov SelectBBits,eax
mov SelectBBits+4,eax
mov eax,10 ; Right shift count for B
mov ebx,5 ; Right shift count for G
mov ShiftCountForB,eax
mov ShiftCountForG,ebx
mov ShiftCountForR,ecx
jmp CCTypeInitialized
CCTypeIs664:
mov eax,000000400H ; Dither pattern.
mov ebx,001000000H
mov DitherB,ebx
mov DitherB+4,ebx
mov DitherG,eax
mov DitherG+4,eax
mov DitherR,eax
mov DitherR+4,eax
mov eax,003F003F0H ; Bits to extract for fields
mov ebx,0FC00FC00H
mov SelectGBits,eax
mov SelectGBits+4,eax
mov SelectRBits,ebx
mov SelectRBits+4,ebx
mov eax,0000F000FH
mov ecx,1 ; Left shift count for R
mov SelectBBits,eax
mov SelectBBits+4,eax
mov eax,11 ; Right shift count for B
mov ebx,5 ; Right shift count for G
mov ShiftCountForB,eax
mov ShiftCountForG,ebx
mov ShiftCountForR,ecx
CCTypeInitialized:
mov esi,YCursor
mov ebp,YPitch
mov edi,StartIndexOfYLine
xor eax,eax
lea edx,[esi+ebp*2]
xor ebx,ebx
mov YCursor,edx
mov bl,[esi+ebp*1] ; Get Y10 (a of line L3; for left edge).
mov al,[esi] ; Get Y00 (A of line L2; for left edge).
movq mm1,Luma0020004000200000[ebx*8] ; L1:< 32a 64a 32a 0 >
mov bl,[esi+ebp*1+2] ; Get c.
movq mm0,Luma0020004000200000[eax*8] ; L0:< 32A 64A 32A 0 >
mov al,[esi+2] ; Get C.
; esi -- Cursor over input line of Y.
; edi -- Index to lines of filtered Y. Quit when MAXWIDTH*20.
; ebp -- Pitch from one line of Y to the next.
; al, bl -- Y pels
; mm0 -- For line 0, contribution of pel to left of two pels under cursor now.
; mm1 -- For line 1, contribution of pel to left of two pels under cursor now.
; mm2-mm6 -- Scratch.
Next2PelsOfFirst2LumaLines:
movq mm3,Luma0020004000200000[ebx*8] ; L1:< 32c 64c 32c 0 >
psrlq mm1,32 ; L1:< 0 0 32a 64a >
movq mm2,Luma0020004000200000[eax*8] ; L0:< 32C 64C 32C 0 >
punpckldq mm1,mm3 ; L1:< 32c 0 32a 64a >
xor ebx,ebx
xor eax,eax
mov bl,[esi+ebp*1+1] ; Get b.
psrlq mm0,32 ; L0:< 0 0 32A 64A >
mov al,[esi+1] ; Get B.
add edi,40 ; Inc filtered luma temp stg idx.
paddw mm1,Luma0020004000200000[ebx*8] ; L1:< 32b+32c 64b 32a+32b 64a >
punpckldq mm0,mm2 ; L0:< 32C 0 32A 64A >
paddw mm0,Luma0020004000200000[eax*8] ; L0:< 32B+32C 64B 32A+32B 64A >
movq HFiltLinePrev[edi-40],mm1 ; Save L1 as next iters LPrev.
paddw mm1,mm0 ; L0+L1
paddw mm0,mm0 ; 2L0
add esi,2 ; Increment input index.
movq FiltLine3[edi-40],mm1 ; Save filtered line L0+L1.
movq mm1,mm3 ; Next iters a.
movq FiltLine2[edi-40],mm0 ; Save filtered line 2L0.
movq mm0,mm2 ; Next iters A.
mov bl,[esi+ebp*1+2] ; Get c.
cmp edi,MAXWIDTH*20-40 ; Done yet.
mov al,[esi+2] ; Get C.
jl Next2PelsOfFirst2LumaLines
xor ebx,ebx
xor ecx,ecx
mov bl,[esi+ebp*1+1] ; Get c.
cmp edi,MAXWIDTH*20 ; Done yet.
mov al,[esi+1] ; Get C.
jl Next2PelsOfFirst2LumaLines
mov ebp,DistanceFromUToV
lea eax,FiltLine2
mov esi,UCursor
mov edx,StartIndexOfYLine
jmp DoOutputLine
Last2OutputLines:
mov ebp,DistanceFromUToV
lea esi,[edi+40]
ja Done
; edi -- Index to lines of filtered Y. Quit when MAXWIDTH*20.
; mm0-mm6 -- Scratch.
movq mm0,HFiltLinePrev[edi] ; Fetch horizontally filtered line LP.
paddw mm0,mm0 ; 2LP
Next2PelsOfLast2LumaLines:
movq FiltLine3[edi],mm0 ; Save horz and vert filt line 2LP.
movq FiltLine2[edi],mm0 ; Save horz and vert filt line 2LP.
movq mm0,HFiltLinePrev[edi+40]; Fetch horizontally filtered line LP.
add edi,40
paddw mm0,mm0 ; 2LP
cmp edi,MAXWIDTH*20 ; Done yet.
jne Next2PelsOfLast2LumaLines
lea eax,FiltLine2
mov edx,StartIndexOfYLine
mov esi,UCursor
jmp DoOutputLine
Next4OutputLines:
mov esi,YCursor
mov ebp,YPitch
mov edi,StartIndexOfYLine
mov ecx,YLimit
lea edx,[esi+ebp*2]
xor eax,eax
mov YCursor,edx
xor ebx,ebx
mov al,[esi] ; Get Y00 (A of line L2; for left edge).
cmp esi,ecx
mov bl,[esi+ebp*1] ; Get Y10 (a of line L3; for left edge).
jae Last2OutputLines
movq mm1,Luma0020004000200000[ebx*8] ; L1:< 32a 64a 32a 0 >
mov bl,[esi+ebp*1+2] ; Get c.
movq mm0,Luma0020004000200000[eax*8] ; L0:< 32A 64A 32A 0 >
mov al,[esi+2] ; Get C.
; esi -- Cursor over input line of Y.
; edi -- Index to lines of filtered Y. Quit when MAXWIDTH*20.
; ebp -- Pitch from one line of Y to the next.
; al, bl -- Y pels
; mm0 -- For line 0, contribution of pel to left of two pels under cursor now.
; mm1 -- For line 1, contribution of pel to left of two pels under cursor now.
; mm2-mm6 -- Scratch.
Next2PelsOf2LumaLines:
movq mm3,Luma0020004000200000[ebx*8] ; L1:< 32c 64c 32c 0 >
psrlq mm1,32 ; L1:< 0 0 32a 64a >
movq mm2,Luma0020004000200000[eax*8] ; L0:< 32C 64C 32C 0 >
punpckldq mm1,mm3 ; L1:< 32c 0 32a 64a >
movq mm4,HFiltLinePrev[edi] ; LP
psrlq mm0,32 ; L0:< 0 0 32A 64A >
xor ebx,ebx
xor eax,eax
mov bl,[esi+ebp*1+1] ; Get b.
movq mm5,mm4 ; LP
mov al,[esi+1] ; Get B.
add esi,2 ; Increment input index.
paddw mm1,Luma0020004000200000[ebx*8] ; L1:< 32b+32c 64b 32a+32b 64a >
punpckldq mm0,mm2 ; L0:< 32C 0 32A 64A >
paddw mm0,Luma0020004000200000[eax*8] ; L0:< 32B+32C 64B 32A+32B 64A >
paddw mm5,mm5 ; 2LP
movq HFiltLinePrev[edi],mm1 ; Save L1 as next iters LPrev.
paddw mm4,mm0 ; LP+L0
movq FiltLine0[edi],mm5 ; Save 2LP
paddw mm1,mm0 ; L0+L1
movq FiltLine1[edi],mm4 ; Save LP+L0
paddw mm0,mm0 ; 2L0
movq FiltLine3[edi],mm1 ; Save L0+L1
movq mm1,mm3 ; Next iters a.
movq FiltLine2[edi],mm0 ; Save 2L0
movq mm0,mm2 ; Next iters A.
add edi,40 ; Inc filtered luma temp stg idx.
mov bl,[esi+ebp*1+2] ; Get c.
cmp edi,MAXWIDTH*20-40 ; Done yet.
mov al,[esi+2] ; Get C.
jl Next2PelsOf2LumaLines
xor ebx,ebx
xor ecx,ecx
mov bl,[esi+ebp*1+1] ; Get c.
cmp edi,MAXWIDTH*20 ; Done yet.
mov al,[esi+1] ; Get C.
jl Next2PelsOf2LumaLines
mov ebp,DistanceFromUToV
mov esi,UCursor
lea eax,FiltLine0
mov edx,StartIndexOfYLine
DoOutputLine:
mov edi,CCOCursor
mov ecx,AspectCount
dec ecx ; If count is non-zero, we keep the line.
mov ebx,CCOPitch
mov AspectCount,ecx
je SkipOutputLine
add ebx,edi
xor ecx,ecx
mov cl,[esi]
add eax,MAXWIDTH*20
movdt mm3,ShiftCountForB
pcmpeqw mm6,mm6
movdt mm0,UContribToBandG[ecx*4] ; < 0 0 Bu Gu >
mov cl,[esi+ebp*1]
sub edx,MAXWIDTH*20
movdt mm4,ShiftCountForG
psllw mm6,15 ; Four words of -32768
movdt mm5,ShiftCountForR
punpcklwd mm0,mm0 ; < Bu Bu Gu Gu >
movq mm7,SelectBBits
mov CCOCursor,ebx
jmp StartDoOutputLine
; ebp -- Distance from U to V
; esi -- Cursor over U
; edi -- Cursor over output
; edx -- Index over Y storage area
; eax -- Base address of Y line
; mm6 -- Four words of -32768, to clamp at floor.
; mm3, mm4, mm5 -- Shift counts to apply to R, G, and B.
DoNext4OutputPels:
movq [edi-8],mm2 ; Save 4 output pels.
punpcklwd mm0,mm0 ; < Bu Bu Gu Gu >
StartDoOutputLine:
movdt mm2,VContribToRandG[ecx*4] ; < 0 0 Rv Gv >
punpcklwd mm2,mm2 ; < Rv Rv Gv Gv >
movq mm1,mm0 ; < junk junk Gu Gu >
punpckhdq mm0,mm0 ; < Bu Bu Bu Bu >
paddsw mm0,[eax+edx] ; < B B B B > with ceiling clamped.
paddw mm1,mm2 ; < junk junk Guv Guv >
paddsw mm0,DitherB ; B with dither added.
punpckldq mm1,mm1 ; < Guv Guv Guv Guv >
paddsw mm1,[eax+edx] ; < G G G G > with ceiling clamped.
punpckhdq mm2,mm2 ; < Rv Rv Rv Rv >
paddsw mm1,DitherG ; G with dither added.
paddsw mm0,mm6 ; B with floor clamped.
paddsw mm2,[eax+edx] ; < R R R R > with ceiling clamped.
paddsw mm1,mm6 ; G with floor clamped.
paddsw mm2,DitherR ; R with dither added.
psrlw mm0,mm3 ; Position B bits.
paddsw mm2,mm6 ; R with floor clamped.
psrlw mm1,mm4 ; Position G bits.
pand mm1,SelectGBits ; Eliminate fractional bits.
psllw mm2,mm5 ; Position R bits.
inc esi ; Advance input cursor
xor ecx,ecx
pand mm2,SelectRBits ; Eliminate fractional bits.
pand mm0,mm7
mov cl,[esi] ; Fetch next U.
add edi,8 ; Advance output cursor.
por mm2,mm0 ; R and B combined.
add edx,40 ; Increment Y index.
movdt mm0,UContribToBandG[ecx*4] ; < 0 0 Bu Gv > next iter.
por mm2,mm1 ; Completed RGB16 for 4 output pels.
mov cl,[esi+ebp*1] ; Fetch next V.
jne DoNext4OutputPels
movq [edi-8],mm2 ; Save 4 output pels.
movq mm0,DitherB ; Reverse dither patterns.
movq mm1,DitherG
psrlq mm0,16
movq mm2,DitherR
psrlq mm1,16
psrlq mm2,16
punpckldq mm0,mm0
punpckldq mm1,mm1
movq DitherB,mm0
punpckldq mm2,mm2
movq DitherG,mm1
movq DitherR,mm2
PrepareForNextOutputLine:
mov edx,StartIndexOfYLine
add eax,8-MAXWIDTH*20 ; Advance to next filtered line of Y.
mov esi,UCursor
test al,8 ; Jump if just did line 0 or 2.
mov ebx,ChromaPitch
jne DoOutputLine
add esi,ebx ; Advance to next chroma line.
test al,16 ; Jump if about to do line 2.
mov UCursor,esi
jne DoOutputLine
sub esi,ebx ; Done with 4 lines. Restore UCursor.
mov UCursor,esi
jmp Next4OutputLines
SkipOutputLine:
mov ecx,AspectAdjustmentCount
add eax,MAXWIDTH*20
mov AspectCount,ecx
jmp PrepareForNextOutputLine
Done:
mov esp,StashESP
pop ebx
pop ebp
pop edi
pop esi
rturn
MMX_YUV12ToRGB16ZoomBy2 endp
END