windows-server-2003/enduser/netmeeting/av/codecs/intel/h263/i386/dx5aspec.asm

;* *************************************************************************
;*    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) 1995 Intel Corporation.
;*    All Rights Reserved.
;*
;* *************************************************************************

;* -------------------------------------------------------------------------
;* PVCS Source control information:
;*
;*	$Header:   S:\h26x\src\dec\dx5aspec.asv   1.2   01 Sep 1995 17:12:12   DBRUCKS  $
;*
;*	$Log:   S:\h26x\src\dec\dx5aspec.asv  $
;// 
;//    Rev 1.2   01 Sep 1995 17:12:12   DBRUCKS
;// fix shaping
;// 
;//    Rev 1.1   29 Aug 1995 16:49:02   DBRUCKS
;// cleanup comment
;// 
;//    Rev 1.0   23 Aug 1995 12:20:32   DBRUCKS
;// Initial revision.
;*  
;*  NOTE: 
;*			The starting source for this routine came from the PVCS database
;*			for the H261 decoder (aspeccor.asm version 1.1, which is a working
;*          16-bit version).
;* -------------------------------------------------------------------------

;////////////////////////////////////////////////////////////////////////////
; AspectCorrect  -- This function converts the U & V data from 8 bits to 7 bits
;                   and moves the data into the YVU9 format the MRV color
;                   convertors want.  Note: the Y data was already converted
;                   from 8 bits to 7 bits in Convert_Y_8to7_Bit.
;
; 	if (Input Format == YVU9)
;		/* This is needed for looking glass output */
;		copy U and V from src to dst
;	else { /* Input Format == YVU12 */
;		if (shaping) {
;			copy Y from src to dst skiping every 12th line
;			copy UV from src to dst subsampling and dropping one in 12 lines 
;				(although not every 12th).
;		} else {
;			copy UV from src to dst subsampling
;		}
;	}
;        
;	Notes: 
;	* the MRV color converters expect YVU9
;	* we may need to drop every 12th line for aspect ratio correction of the
;	  YVU12 input.
;
;   ASSUMPTIONS/LIMITATIONS:
;   * IF input in YVU12, only 128x96, 176x144, & 352x288 resolutions are 
;     supported.  YVU9 should support all sizes.
;
;-------------------------------------------------------------------------------

include decconst.inc

ifndef WIN32
.MODEL SMALL
endif

.486

ifdef WIN32
.MODEL FLAT
.DATA

else ;; WIN16
_DATA	SEGMENT PUBLIC 'DATA'
endif

;;	Toss lines for aspect ratio correction 12 to 9
;;        6, 19, 30, 43, 54, 67,
;;       78, 91,102,115,126,139

;;	Lookup Table for 8->7 bit conversion and clamping.
;;  U and V range from 16..240->8..120
gTAB_UVtbl8to7  BYTE      8,  8,  8,  8,  8,  8,  8,  8
				BYTE      8,  8,  8,  8,  8,  8,  8,  8  
				BYTE      8,  8,  9,  9, 10, 10, 11, 11
				BYTE     12, 12, 13, 13, 14, 14, 15, 15
				BYTE     16, 16, 17, 17, 18, 18, 19, 19
				BYTE     20, 20, 21, 21, 22, 22, 23, 23
				BYTE     24, 24, 25, 25, 26, 26, 27, 27
				BYTE     28, 28, 29, 29, 30, 30, 31, 31
				BYTE     32, 32, 33, 33, 34, 34, 35, 35
				BYTE     36, 36, 37, 37, 38, 38, 39, 39
				BYTE     40, 40, 41, 41, 42, 42, 43, 43 
				BYTE     44, 44, 45, 45, 46, 46, 47, 47
				BYTE     48, 48, 49, 49, 50, 50, 51, 51
				BYTE     52, 52, 53, 53, 54, 54, 55, 55
				BYTE     56, 56, 57, 57, 58, 58, 59, 59
				BYTE     60, 60, 61, 61, 62, 62, 63, 63
				BYTE     64, 64, 65, 65, 66, 66, 67, 67
				BYTE     68, 68, 69, 69, 70, 70, 71, 71
				BYTE     72, 72, 73, 73, 74, 74, 75, 75
				BYTE     76, 76, 77, 77, 78, 78, 79, 79
				BYTE     80, 80, 81, 81, 82, 82, 83, 83
				BYTE     84, 84, 85, 85, 86, 86, 87, 87
				BYTE     88, 88, 89, 89, 90, 90, 91, 91
				BYTE     92, 92, 93, 93, 94, 94, 95, 95
				BYTE     96, 96, 97, 97, 98, 98, 99, 99
				BYTE    100,100,101,101,102,102,103,103
				BYTE    104,104,105,105,106,106,107,107
				BYTE    108,108,109,109,110,110,111,111
				BYTE    112,112,113,113,114,114,115,115
				BYTE    116,116,117,117,118,118,119,119
				BYTE    120,120,120,120,120,120,120,120
				BYTE    120,120,120,120,120,120,120,120

_DATA	ENDS

ifdef WIN32
.CODE
assume cs : flat
assume ds : flat
assume es : flat
assume fs : flat
assume gs : flat

else
_TEXT32 SEGMENT PUBLIC READONLY USE32 'CODE'
ASSUME	DS:_DATA
ASSUME	CS:_TEXT32
ASSUME	ES:nothing
ASSUME	FS:nothing
ASSUME	GS:nothing
endif

;C function prototype
;
;long AspectCorrect(
;			HPBYTE      pYPlaneInput,  /*ptr Y plane*/
;		    HPBYTE      pVPlaneInput,  /*ptr V plane*/
;		    HPBYTE      pUPlaneInput,  /*ptr U plane*/
;		    DWORD       YResolution,   /*Y plane height*/
;		    DWORD       XResolution,   /*Y plane width*/
;		    WORD far  * pyNewHeight,   /*Pitch of Y plane in*/
;		    DWORD		YVU9InputFlag, /*flag = YUV9 or YUV12*/
;		    HPBYTE      pYPlaneOutput, /*pYOut*/
;		    HPBYTE      pVPlaneOutput, /*pUOut*/
;		    DWORD       YPitchOut,     /*Pitch of Y plane out*/
;		    DWORD		ShapingFlag	   /*flag = Shaping or not*/
;		    )

PUBLIC _AspectCorrect

ifdef WIN32
_AspectCorrect proc

else
_AspectCorrect proc far
;   parmD    pYPlaneIn        ;ptr to Y input plane
;   parmD    pVPlaneIn        ;ptr to V input plane
;   parmD    pUPlaneIn        ;ptr to U input plane
;   parmD    YRes             ;Y plane height
;   parmD    XRes             ;Y plane width
;   parmD    pYNewHeight      ;Pitch of Y plane input
;   parmD    YVU9Flag         ;Flag=1 if YUV9
;   parmD    pYPlaneOut       ;ptr to Y output plane
;   parmD    pVPlaneOut       ;ptr to V output plane
;   parmD    YPitchOut        ;Pitch of Y plane output
;   parmD    ShapingFlag      ;Flag=1 if Shaping

endif


;set up equates
pYPlaneIn   EQU  DWORD PTR[ebp+8]
pVPlaneIn   EQU  DWORD PTR[ebp+12]
pUPlaneIn   EQU  DWORD PTR[ebp+16]
YRes        EQU  DWORD PTR[ebp+20]
XRes        EQU  DWORD PTR[ebp+24]
pYNewHeight EQU  DWORD PTR[ebp+28]
YVU9Flag    EQU  DWORD PTR[ebp+32]
pYPlaneOut  EQU  DWORD PTR[ebp+36]
pVPlaneOut  EQU  DWORD PTR[ebp+40]
YPitchOut   EQU  DWORD PTR[ebp+44]
ShapingFlag EQU  DWORD PTR[ebp+48]

;; stack usage
; previous ebp at ebp 
; previous edi at ebp - 4
; previous esi at ebp - 8
; lXRes        at ebp -12
; lYRes        at ebp -16
; lYPitchOut   at ebp -20
; YDiff        at ebp -24
; outloopcnt   at ebp -28
; uvWidth      at ebp -32
; inloopcnt    at ebp -36
; luvcounter   at ebp -40
; uvoutloopcnt at ebp -44
; VDiff        at ebp -48
; VInDiff	   at ebp -52

lXRes        EQU  DWORD PTR[ebp-12]
lYRes        EQU  DWORD PTR[ebp-16]
lYPitchOut   EQU  DWORD PTR[ebp-20]
YDiff        EQU  DWORD PTR[ebp-24]
outloopcnt   EQU  DWORD PTR[ebp-28]
uvWidth      EQU  DWORD PTR[ebp-32]
inloopcnt    EQU  DWORD PTR[ebp-36]
luvcounter   EQU  DWORD PTR[ebp-40]
uvoutloopcnt EQU  DWORD PTR[ebp-44]
VDiff        EQU  DWORD PTR[ebp-48]
VInDiff      EQU  DWORD PTR[ebp-52]

  xor   ax,ax           ; These two instructions give definitive proof we are
  mov   eax,0CCCCCCCCH  ; in a 32-bit code segment.  INT 3 occurs if not.

;get params
	push    ebp

ifdef WIN32
	mov     ebp, esp
else
	movzx  	ebp, sp	        ;ebp now pointing to last pushed reg
endif
	  push    edi
	push    esi

; zero out registers
	xor 	edx, edx

	xor	esi, esi
	xor	edi, edi

; move stack variables to local space
	mov	eax, XRes
	push	eax		; store lXRes on stack

	mov	ebx, YRes
	push	ebx		; store lYRes on stack

	mov	ecx, YPitchOut
	push	ecx		; store lYpitchOut on stack
	sub	ecx, eax	; YDiff = YPitchOut - XRes
	push	ecx		; store YDiff on stack

; push stack with 0 6 additional times to make room for other locals
	push	edx		; outloopcnt
	push	edx		; uvWidth
	push	edx		; inloopcnt
	push	edx		; luvcounter
	push	edx		; uvoutloopcnt
	push	edx		; VDiff
	push    edx     ; VInDiff

; test if YUV9 mode
	mov     edx, YVU9Flag
	test    edx,edx
	jz      YVU12;      ; If the flag is false it must be YVU12

;**********************************************************************
;**********************************************************************
; know input was YVU9, Y Plane was processed in cc12to7.asm

	mov esi, pYNewHeight
	mov	WORD PTR [esi], bx	; store YRes into address pYNewHeight

; ********************
; Copy V and U Plane from source to destination converting to 7 bit
; ********************
; Description of V & U Plane processing:
;   - Double nested loop with 
;     Outlp1 executed YRes/4 lines 
;       Collp1 loops for number of columns
;         - Read 1 U
;	  - Read 1 V
;         - Convert each value from 8-bit to 7-bit
;         - Store 1 U
;         - Store 1 V
;
; Register usage
;   eax	U plane input address
;   ebx	source value and index into gTAB_UVtbl8to7
;   ecx	source value and index into gTAB_UVtbl8to7
;   edx	inner most loop counter 
;   esi	V plane src address
;   edi	des address
;   ebp	stack pointer stuff
;
; if (16-bit)
;   es	input plane segment
;   fs	output plane segment
;   ds	table segment
; endif
;
; local variables
;  outloopcnt
;  lXRes
;  lYRes
;  uvWidth
;  VDiff
;
; know input was YVU9
	mov	ecx, lYRes
	  mov	ebx, lXRes
	shr	ebx, 2			; uvWidth=XRes/4
	  mov	eax, VPITCH		; get Fixed offset
	shr	ecx, 2			; outloopcnt=YRes/4
	  mov	uvWidth,ebx		; uvWidth=XRes/4
	sub	eax, ebx		; VPITCH - uvWidth

	mov	esi,  pVPlaneIn		; Initialize input cursor
	mov	edi,  pVPlaneOut	; Initialize output cursor
	  mov	VDiff, eax		; store V difference
	mov	eax,  pUPlaneIn		; Initialize input cursor
	
Row9lp2:
	mov	outloopcnt,ecx		; store updated outer loop count
	  mov	edx, uvWidth		; init dx
	xor	ebx, ebx
	  xor	ecx, ecx

Col9lpv1:
  	mov  	cl, BYTE PTR [eax]	      ; Fetch *PUtemp_IN
	  inc	edi			              ; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	      ; Fetch *pVtemp_IN
	  inc	eax			              ; pUtemp+=1
	mov	    cl, gTAB_UVtbl8to7[ecx]	  ; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  inc	esi			              ; Inc source by 1,pVtemp+=1
	mov  	BYTE PTR [edi+167],cl     ; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	  ; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	      ; store in PVtemp_OUT
	  xor	ecx, ecx	              ; dummy op
	dec	edx
	  jg  	Col9lpv1

;; increment to beginning of next line
	mov	edx, VDiff

	mov	ecx, outloopcnt		; get outer loop count
	  add	edi,edx			; Point to next output row
	dec	ecx
	  jnz	Row9lp2			; if more to do loop

	jmp	Cleanup

;*****************************************************************
;*****************************************************************
; know input was YVU12
;
;    if (!ShapingFlag) {
;        goto YVU12_NO_SHAPING;
;    } else {
;        switch (YRes) {  // YRes = YRes * 11 / 12;
;        case  96: *pyNewHeight =  88; break;
;        case 144: *pyNewHeight = 132; break;
;        case 288: *pyNewHeight = 264; break;
;        default: error;
;        }
;    }
;
YVU12:
	mov  eax, ShapingFlag
	test eax, eax
	jz   YVU12_NO_SHAPING
	
	cmp lYRes, 96       ; If 96
	je  YRes96
	cmp	lYRes, 144		; If 144 
	je	YRes144
	cmp	lYRes, 288		; If 288
	je	YRes288
	jmp	Error
;
YRes96:
	mov	ax, 88          ; pyNewHeight = ax = 132
	mov	ecx, 7			; for YRes lines loopcounter=11
	mov	uvoutloopcnt, 1	; process 1 full set of 13&11 lines
	jmp	Rejoin2

YRes144:
	mov	ax, 132			; pyNewHeight = ax = 132
	mov	ecx, 11			; for YRes lines loopcounter=11
	mov	uvoutloopcnt, 2	; process 2 full sets of 13&11 lines
	jmp	Rejoin2

YRes288:
	mov	ax, 264			; pyNewHeight = ax = 264
	mov	ecx, 23			; for YRes lines loopcounter=23
	mov	uvoutloopcnt, 5	; process 5 full sets of 13&11 lines

Rejoin2:
	mov	esi, pYNewHeight
	mov	[esi], ax	    ; store adjusted height into 
					            ; address pYNewHeight
; ********************
; Copy Y Plane from soure to dest skipping every 12th line 
; ********************
; Description of YPlane processing:
;
; Triple nested loop with 
; Outlp1 executed 11 or 23 times based on 144 or 288 lines respectively
;   Rowlp1 is executed 11 times 
;     Collp1 loops for number of columns
;
; Register usage
;  eax	rows loop count
;  ebx	input and output
;  ecx	outer loop count
;  edx	column loop counter 
;  esi	src address
;  edi	des address
;  ebp	stack pointer stuff
;
;  es	input plane segment
;  fs	output plane segment
;  ds	table segment
;
; local variables
;  lXRes
;  YDiff
;  lYPitchOut
;
	mov esi,  pYPlaneIn		; Initialize input cursor
	mov	edi,  pYPlaneOut		; Initialize output cursor

; No need to re-copy first 11 lines
	mov	eax, lYPitchOut
	  mov	edx, YDiff
	add	edi, eax		; des + 1*lYPitchOut
	shl	eax, 1			; lYPitchOut*2
;;;	add	esi, edx		; Adjust for difference in YPitchOut
					;   and XRes
	  add	edi, eax		; des + 3*lYpitchOut
	shl	eax, 1			; lYPirchOut*4
;;;	add	edi, edx		; Adjust for difference in YPitchOut
					;   and XRes
	  add	esi, eax		; source + 4*lYpitchOut
	shl	eax, 1			; lYPitchOut*8
	add	esi, eax		; source +12*lYpitchOut
	  add	edi, eax		; des + 11*lYPitchOut

Outlp1:
	mov	eax, 11 		; Initialize rows loop cnter
	  mov	edx, lXRes		; edx = number of columns

Rowlp1:
Collp1:
  	mov  	ebx, [esi+edx-4]	; Fetch source, 4 at a time
	  sub  	edx,4			; decrement loop counter
	mov  	[edi+edx],ebx	; Store 4 converted values
	  jnz  	Collp1			; if not done loop

	mov	edx, lYPitchOut
	  mov	ebx, YDiff
	add	edi, edx		; Increment to where just processed
	  add	esi, edx
;;;	add	edi, ebx		; Adjust for difference in YPitchOut
;;;	  add	esi, ebx		;  and XRes
	dec	eax			; decrement rows loop counter
	  jg	Rowlp1

	mov	eax,lYPitchOut		; Skip 12th line
	add	esi,eax			; Point to next input row

	dec	ecx			; decrement outer loop counter
	  jg	Outlp1			; if more to do loop

; ************************************************************
; Copy V and U Plane from source to destination converting to 7 bit
;   skipping every other line and sometimes two moving only ever other 
;   pixel in a row.
; ********************
;
; Description of V & U Plane processing:
;   - Double nested loop with 
;     Outlp1 executed YRes/4 lines 
;       Collp1 loops for number of columns
;         - Read 1 U
;	  - Read 1 V
;         - Convert each value from 8-bit to 7-bit
;         - Store 1 U
;         - Store 1 V
;
; Register usage
;   eax	U plane input address
;   ebx	source value and index into gTAB_UVtbl8to7
;   ecx	source value and index into gTAB_UVtbl8to7
;   edx	counter
;   esi	V plane src address
;   edi	des address, V Plane and U Plane
;   ebp	stack pointer stuff
;
;   es	input plane segment
;   fs	output plane segment
;   ds	table segment
;
; local variables
;  luvcounter
;  uvoutloopcnt
;  inloopcnt
;  lXRes
;  uvWidth
;  VDiff
;
	mov	ebx, lXRes
	  mov	eax, VPITCH		; get Fixed offset
	shr	ebx, 1			; uvWidth=XRes/2
	mov	uvWidth, ebx		; uvWidth=XRes/2
	shr	ebx, 1
	sub	eax, ebx		; VPITCH - uvWidth
	mov	VDiff, eax		; store V difference
	  mov	luvcounter, ebx		; luvcounter = XRes/4

	mov     ecx, YPITCH		; Distance to the next V
	  add   ecx, ecx
	sub     ecx, uvWidth           
	  mov   VInDiff, ecx    ;	 = YPITCH + YPITCH - uvWidth 

	mov	esi,  pVPlaneIn		; Initialize input cursor
	mov	edi,  pVPlaneOut		; Initialize output cursor
	mov	eax,  pUPlaneIn		; Initialize input cursor

; Process 6 first lines special
	mov	ebx, 3			; initialize inner loop count 
	
Rowlp2_6:
	mov	edx, luvcounter		; init dx
	  mov	inloopcnt, ebx		; store updated inloopcnt
	xor	ebx, ebx
	  xor	ecx, ecx

Collpv1:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1

; increment to beginning of next line then skip next input line
	add	    edi,VDiff		; Point to next output row
	  mov	edx,VInDiff		; Skip to next input row
	add	    esi,edx			; 
	  add	eax,edx			; 

; test if have processed 6 lines yet
	mov	ebx, inloopcnt
	dec	ebx
	  jg	Rowlp2_6		; if more to do loop

; Skipping extra line
	mov	edx,YPITCH		; Need same sized for add
	  mov	ecx, uvoutloopcnt
	add	esi,edx			; Point to next input row
	  add	eax,edx			; Point to next input row

; Process groups of 13 and 11 lines
Outlp2:

;   Process 13 lines
	mov	ebx, 6			; initialize inner loop count 
	  mov	uvoutloopcnt, ecx

Rowlp2_13:
	mov	edx, luvcounter		; init dx
	  mov	inloopcnt, ebx		; store updated inloopcnt
	xor	ebx, ebx
	  xor	ecx, ecx

Collpv1_13:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1_13

; increment to beginning of next line then skip next input line
	add	    edi,VDiff		; Point to next output row
	  mov	edx,VInDiff		; Skip to next input row
	add	    esi,edx			; 
	  add	eax,edx			; 

; test if have processed 13 lines yet
	mov	ebx, inloopcnt
	dec	ebx
	  jg	Rowlp2_13		; if more to do loop

; Skipping extra line
	mov	    edx,YPITCH 		; Need same sized for add
	  mov	ebx, 5			; initialize inner loop count 
	add	    esi,edx			; Point to next input row
	  add	eax,edx			; Point to next input row

;   Process 11 lines
Rowlp2_11:
	mov	edx, luvcounter		; init dx
	  mov	inloopcnt, ebx		; store updated inloopcnt
	xor	ebx, ebx
	  xor	ecx, ecx

Collpv1_11:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1_11

; increment to beginning of next line, then skip next input line
	add	    edi, VDiff		; Point to next output row
	  mov	edx,VInDiff		; Skip to next input row
	add	    esi,edx			; 
	  add	eax,edx			; 

; test if have processed 11 lines yet
	mov	ebx, inloopcnt
	dec	ebx
	  jg	Rowlp2_11		; if more to do loop

; Skipping extra line
	mov	    edx,YPITCH		; Need same sized for add
	  mov	ecx, uvoutloopcnt
	add	    esi,edx			; Point to next input row
	  add	eax,edx			; Point to next input row

	dec	ecx
	  jnz	Outlp2			; if more to do loop

;
; Process last set of 13
;
	mov	ebx, 6			; initialize inner loop count 

Rowlp2_13l:
	mov	edx, luvcounter		; init dx
	  mov	inloopcnt, ebx		; store updated inloopcnt
	xor	ebx, ebx
	  xor	ecx, ecx

Collpv1_13l:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1_13l

; increment to beginning of next line then skip next input line
	add	    edi,VDiff		; Point to next output row
	  mov	edx,VInDiff		; Skip to next input row
	add	    esi,edx			; 
	  add	eax,edx			; 

; test if have processed 13 lines yet
	mov	ebx, inloopcnt
	dec	ebx
	  jg	Rowlp2_13l		; if more to do loop

; Skipping extra line
	mov	    edx,YPITCH		; Need same sized for add
	  mov	ebx, 2			; initialize inner loop count 
	add	    esi,edx			; Point to next input row
	  add	eax,edx			; Point to next input row

; Process final 4 lines
Rowlp2_f:
	mov	edx, luvcounter		; init dx
	  mov	inloopcnt, ebx
	xor	ebx, ebx
	  xor	ecx, ecx

Collpv1_f:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1_f

; increment to beginning of next line then skip next input line
	add	    edi, VDiff		; Point to next output row
	  mov	edx,VInDiff		; Skip to next input row
	add	    esi,edx			; 
	  add	eax,edx			; 

; test if have processed last lines yet
	mov	ebx, inloopcnt
	dec	ebx
	  jg	Rowlp2_f		; if more to do loop

	jmp	Cleanup

; ************************************************************
; Copy V and U Plane from source to destination converting to 7 bit
;   skipping every other line moving only ever other pixel in a row.
; ********************
;
; Description of V & U Plane processing:
;   - Double nested loop with 
;     Outlp1 executed YRes/4 lines 
;       Collp1 loops for number of columns
;         - Read 1 U
;	  - Read 1 V
;         - Convert each value from 8-bit to 7-bit
;         - Store 1 U
;         - Store 1 V
;
; Register usage
;   eax	U plane input address
;   ebx	source value and index into gTAB_UVtbl8to7
;   ecx	source value and index into gTAB_UVtbl8to7
;   edx	counter
;   esi	V plane src address
;   edi	des address, V Plane and U Plane
;   ebp	stack pointer stuff
;
;   es	input plane segment
;   fs	output plane segment
;   ds	table segment
;
; local variables
;  luvcounter
;  inloopcnt
;  lYRes
;  lXRes
;  uvWidth
;  VDiff
;  VInDiff
;
YVU12_NO_SHAPING:   
	cmp lYRes, 98
	je  YRes98_NS
	cmp	lYRes, 144		 
	je	YRes144_NS
	cmp	lYRes, 288		
	je	YRes288_NS
	jmp	Error
;
YRes98_NS:    ;  98 No Shaping           
YRes144_NS:	  ; 144 No Shaping
YRes288_NS:   ; 288 No Shaping
	mov	eax, lYRes		; pyNewHeight = ax = YRes
	mov	esi, pYNewHeight
	mov	[esi], ax	; store adjusted height into 

	shr	eax, 2			; inloopcnt=YRes/2
	 mov	ebx, lXRes
	shr	ebx, 1			; uvWidth=XRes/2
	  mov	inloopcnt, eax		; initialize inner loop count 
	mov	uvWidth, ebx		; uvWidth=XRes/2
	  mov	ecx, VPITCH		; get output plane V pitch
	shr	ebx, 1
	  sub	ecx, ebx		; VPITCH - uvWidth/2
	mov	luvcounter, ebx		; luvcounter = XRes/4
	  mov	VDiff, ecx		; Store VDiff

	mov     ecx, YPITCH		; Distance to the next V
	  add   ecx, ecx
	sub     ecx, uvWidth           
	  mov   VInDiff, ecx    ;	 = YPITCH + YPITCH - uvWidth 

	mov	esi,  pVPlaneIn		; Initialize input cursor
	mov	edi,  pVPlaneOut		; Initialize output cursor
	mov	eax,  pUPlaneIn		; Initialize input cursor
	  mov	ecx, inloopcnt

; Process all lines skipping just every other

Rowlp2_NS:
	mov	inloopcnt, ecx		; store update inloopcnt
	  xor	ebx, ebx
	mov	edx, luvcounter		; init dx
	  xor	ecx, ecx

Collpv1_NS:
  	mov  	cl, BYTE PTR [eax]	; Fetch *PUtemp_IN
	  inc	edi			; Inc des by 1, PVtemp_OUT++
  	mov  	bl, BYTE PTR [esi]	; Fetch *pVtemp_IN
	  add	eax,2			; pUtemp+=2
	mov	cl, gTAB_UVtbl8to7[ecx]	; cl = gTAB_UVtbl8to7[*pUtemp_IN]
	  add	esi,2			; Inc source by 2,pVtemp+=2
	mov  	BYTE PTR [edi+167],cl; store in PUtemp_OUT
	  mov	bl, gTAB_UVtbl8to7[ebx]	; bl = gTAB_UVtbl8to7[*pVtemp_IN]
	mov  	BYTE PTR [edi-1],bl	; store in PVtemp_OUT
	  xor	ecx, ecx		; dummy op
	dec	edx
	  jg  	Collpv1_NS

; increment to beginning of next line then skip next input line
	add	edi, VDiff		; Point to next output row
	  mov	edx,VInDiff	; Skip to next input row
	add	esi,edx			; 
	  add	eax,edx			; 
	mov	ecx, inloopcnt		; get inloopcnt

; test if have processed all lines yet
	dec	ecx			; Process next line
	  jne	Rowlp2_NS		; if more to do loop

Error:
Cleanup:
; clean out local variables on stack
	pop	ecx
	  pop	ebx
	pop	ecx
	  pop	ebx
	pop	ecx
	  pop	ebx
	pop	ecx
	  pop	ebx
	pop	ecx
	  pop	ebx
	pop ecx

;clear special seg registers, restore stack, pop saved registers
ifndef WIN32
	xor     ecx, ecx
	xor     ebx, ebx
	mov     es, cx
	mov     fs, bx
endif
	  pop     esi
	pop     edi
	  pop     ebp

ifdef WIN32
	ret
else
	db      066h
	retf
endif

_AspectCorrect endp

END