/* *************************************************************************
**    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.
**
** *************************************************************************
*/

//////////////////////////////////////////////////////////////////////////
// $Author:   AGUPTA2  $
// $Date:   22 Mar 1996 17:23:16  $
// $Archive:   S:\h26x\src\dec\d3bvriq.cpv  $
// $Header:   S:\h26x\src\dec\d3bvriq.cpv   1.7   22 Mar 1996 17:23:16   AGUPTA2  $
// $Log:   S:\h26x\src\dec\d3bvriq.cpv  $
// 
//    Rev 1.7   22 Mar 1996 17:23:16   AGUPTA2
// Minor interface change to accomodate MMX rtns.  Now the interface is the
// same for MMX and IA.
// 
//    Rev 1.6   08 Mar 1996 16:46:10   AGUPTA2
// Added pragma code_seg.
// 
// 
//    Rev 1.5   15 Feb 1996 14:54:08   RMCKENZX
// Gutted and re-wrote routine, optimizing for performance
// for the p5.  Added clamping to -2048...+2047 to escape code
// portion.
// 
//    Rev 1.4   27 Dec 1995 14:36:00   RMCKENZX
// Added copyright notice
// 
//    Rev 1.3   09 Dec 1995 17:35:20   RMCKENZX
// Re-checked in module to support decoder re-architecture (thru PB frames)
// 
//    Rev 1.0   27 Nov 1995 14:36:46   CZHU
// Initial revision.
// 
//    Rev 1.28   03 Nov 1995 16:28:50   CZHU
// Cleaning up and added more comments
// 
//    Rev 1.27   31 Oct 1995 10:27:20   CZHU
// Added error checking for total run value.
// 
//    Rev 1.26   19 Sep 1995 10:45:12   CZHU
// 
// Improved pairing and cleaned up
// 
//    Rev 1.25   18 Sep 1995 10:20:28   CZHU
// Fixed bugs in handling escape codes for INTER blocks w.r.t. run.
// 
//    Rev 1.24   15 Sep 1995 09:35:30   CZHU
// fixed bugs in run cumulation for inter
// 
//    Rev 1.23   14 Sep 1995 10:13:32   CZHU
// 
// Initialize cumulated run for the INTER blocks.
// 
//    Rev 1.22   12 Sep 1995 17:36:06   AKASAI
// 
// Fixed bug in addressing to Intermediate when changed from writing
// BYTES to DWORDS.  Inter Butterfly only had the problem.
// 
//    Rev 1.21   12 Sep 1995 13:37:58   AKASAI
// Added Butterfly Inter code.  Also added optimizations to pre-fetch
// accumulators and "output" cache lines.
// 
//    Rev 1.20   11 Sep 1995 16:41:32   CZHU
// Adjust target block address: write to Target if INTRA, write to tempory sto
// 
//    Rev 1.19   11 Sep 1995 14:30:32   CZHU
// Seperate Butterfly for inter and intra, put place holder for inter blocks
// 
//    Rev 1.18   08 Sep 1995 11:49:00   CZHU
// Added support for P frames, fixed bugs related to INTRADC's presence.
// 
//    Rev 1.17   28 Aug 1995 14:51:22   CZHU
// Improve pairing and clean up
// 
//    Rev 1.16   24 Aug 1995 15:36:24   CZHU
// 
// Fixed bugs handling the escape code followed by 22bits fixed length code
// 
//    Rev 1.15   23 Aug 1995 14:53:32   AKASAI
// Changed butterfly writes to increment by bytes and take a PITCH.
// 
//    Rev 1.14   23 Aug 1995 11:58:46   CZHU
// Added signed extended inverse quant before calling idct. and others 
// 
//    Rev 1.13   22 Aug 1995 17:38:28   CZHU
// Calls the idct accumulation for each symbol and butterfly at the end.
// 
//    Rev 1.12   21 Aug 1995 14:39:58   CZHU
// 
// Added IDCT initialization code and stubs for accumulation and butterfly.
// Also added register saving and restoration before and after accumulation
// 
//    Rev 1.11   18 Aug 1995 17:03:32   CZHU
// Added comments and clean up for integration with IDCT
// 
//    Rev 1.10   18 Aug 1995 15:01:52   CZHU
// Fixed bugs in handling escape codes using byte oriented reading approach
// 
//    Rev 1.9   16 Aug 1995 14:24:22   CZHU
// Bug fixes for the integration with bitstream parsing. Also changed from DWO
// reading to byte oriented reading.
// 
//    Rev 1.8   15 Aug 1995 15:07:42   CZHU
// Fixed the stack so that the parameters have been passed in correctly.
// 
//    Rev 1.7   14 Aug 1995 16:39:02   DBRUCKS
// changed pPBlock to pCurBlock
// 
//    Rev 1.6   11 Aug 1995 16:08:12   CZHU
// removed local varables in C
// 
//    Rev 1.5   11 Aug 1995 15:51:26   CZHU
// 
// Readjust local varables on the stack. Clear ECX upfront.
// 
//    Rev 1.4   11 Aug 1995 15:14:32   DBRUCKS
// variable name changes
// 
//    Rev 1.3   11 Aug 1995 13:37:26   CZHU
// 
// Adjust to the joint optimation of IDCT, IQ, RLE, and ZZ.
// Also added place holders for IDCT.
// 
//    Rev 1.2   11 Aug 1995 10:30:26   CZHU
// Changed the functions parameters, and added codes to short-curcuit IDCT bef
// 
//    Rev 1.1   03 Aug 1995 14:39:04   CZHU
// 
// further optimization.
// 
//    Rev 1.0   02 Aug 1995 15:20:02   CZHU
// Initial revision.
// 
//    Rev 1.1   02 Aug 1995 10:21:12   CZHU
// Added asm codes for VLD of TCOEFF, inverse quantization, run-length decode.
// 


//--------------------------------------------------------------------------
//
//  d3xbvriq.cpp
//
//  Description:
//    This routine performs run length decoding and inverse quantization
//    of transform coefficients for one block.
//	 MMx version.
//
//  Routines:
//    VLD_RLD_IQ_Block
//
//  Inputs (dwords pushed onto stack by caller):
//    lpBlockAction  pointer to Block action stream for current blk.
//
//	 lpSrc			The input bitstream.
//
//	 uBitsInOut		Number of bits already read.
//
//    pIQ_INDEX		Pointer to coefficients and indices.
//
//    pN				Pointer to number of coefficients read.
//
//  Returns:
//    0 				on bit stream error, otherwise total number of bits read
//					(including number read prior to call).
//
//  Note: 
//			The structure of gTAB_TCOEFF_MAJOR is as follows:
//				bits		name:		description
//				----		-----		-----------
//				25-18		bits:		number of bitstream bits used
//				17			last:		flag for last coefficient
//				16-9		run:		number of preceeding 0 coefficients plus 1
//				8-2			level:		absolute value of coefficient
//				1			sign:		sign of coefficient
//				0			hit:		1 = major table miss, 0 = major table hit
//
//			The structure of gTAB_TCOEFF_MINOR is the same, right shifted by 1 bit. 
//			A gTAB_TCOEFF_MAJOR value of 00000001h indicates the escape code.
//
//--------------------------------------------------------------------------

#include "precomp.h"

// local variable definitions
#define L_Quantizer		esp+20		// quantizer		P_BlockAction
#define L_Quantizer64	esp+24		// 64*quantizer		P_src
#define L_Bits      	esp+28		// bit offset		P_bits
#define L_CumRun		esp+36		// cumulative run	P_dst

// stack use
//	ebp					esp+0
//	esi					esp+4
//	edi					esp+8
//	ebx					esp+12
//	return address		esp+16

// input parameters
#define P_BlockAction 	esp+20		// L_Quantizer
#define P_src			esp+24		// L_Quantizer64
#define P_bits			esp+28		// L_Bits
#define P_num			esp+32		//
#define P_dst			esp+36		// L_CumRun


#pragma code_seg("IACODE1")
extern "C" __declspec(naked)
U32 VLD_RLD_IQ_Block(T_BlkAction *lpBlockAction,
                     U8  *lpSrc, 
                     U32 uBitsread,
                     U32 *pN,
                     U32 *pIQ_INDEX)
{		
	__asm {

// save registers
	push	ebp
	 push	esi 
	push	edi			
	 push	ebx

//
// initialize
//	make sure we read in the P_src and P_dst pointers before we
//	overwrite them with L_Quantizer64 and L_CumRun.
//
//	Output Registers:
//		 dl = block type ([P_BlockAction])
//		esi = bitstream source pointer (P_src)
//		edi = coefficient destination pointer (P_dst)
//		ebp = coefficent counter (init to 0)
//
//	Locals initialized on Stack: (these overwrite indicated input parameters) 
//		local var		clobbers  		initial value
//		---------------------------------------------------
//		L_Quantizer		P_BlockAction	input quantizer
//		L_Quantizer64	P_src			64 * input quantizer
//		L_CumRun 		P_dst			-1
//
	xor 	ebp, ebp						// init coefficient counter to 0
 	 xor 	eax, eax						// zero eax for quantizer & coef. counter

	mov 	ecx, [P_BlockAction]        	// ecx = block action pointer
	 mov 	ebx, -1							// beginning cumulative run value

	mov 	esi, [P_src]  					// esi = bitstream source pointer
	 mov 	edi, [P_dst]					// edi = coefficient pointer

	mov 	al, [ecx+3]						// al = Quantizer
	 mov 	[L_CumRun], ebx					// init cumulative run to -1

	mov 	[L_Quantizer], eax				// save original quantizer
	 mov 	dl, [ecx]						// block type in dl

	shl 	eax, 6							// 64 * Quantizer
 	 mov 	ecx, [L_Bits]					// ecx = L_Bits

	mov 	ebx, ecx						// ebx = L_Bits
	 mov 	[L_Quantizer64], eax				// save 64*Quantizer for this block

	shr 	ebx, 3							// offset for input
	 and 	ecx, 7							// shift value

	cmp 	dl, 1							// check the block type for INTRA
	 ja 	get_next_coefficient			// if type 2 or larger, no INTRADC
	 
//
// Decode INTRADC
//
//	uses dword load & bitswap to achieve big endian ordering.
//	prior codes prepares ebx, cl, and dl as follows:
//		ebx = L_Bits>>3
//		cl  = L_Bits&7
//		dl  = BlockType (0=INTRA_DC, 1=INTRA, 2=INTER, etc.)
//
	mov 	eax, [esi+ebx]					// *** PROBABLE MALALIGNMENT ***
	 inc 	ebp								// one coefficient decoded

	bswap	eax								// big endian order
											// *** NOT PAIRABLE ***

	shl 	eax, cl							// left justify bitstream buffer
											// *** NOT PAIRABLE ***
											// *** 4 CYCLES ***

	shr 	eax, 21							// top 11 bits to the bottom
 	 mov 	ecx, [L_Bits]					// ecx = L_Bits

	and 	eax, 07f8h						// mask last 3 bits
	 add 	ecx, 8							// bits used += 8 for INTRADC

	cmp 	eax, 07f8h						// check for 11111111 codeword
	 jne 	skipa

	mov 	eax, 0400h						// 11111111 decodes to 400h = 1024 

skipa:
	mov 	[L_Bits], ecx					//  update bits used
	 xor 	ebx, ebx

	mov 	[L_CumRun], ebx					// save total run (starts with zero)
	 mov 	[edi], eax						// save decoded DC coefficient

	mov 	[edi+4], ebx					// save 0 index
	 mov 	ebx, ecx						// ebx = L_Bits

	shr 	ebx, 3							// offset for input
	 add 	edi, 8							// update coefficient pointer

//  check for last
	test 	dl, dl							// check for INTRA-DC (block type=0)
	 jz		finish							// if only the INTRADC present


//
// Get Next Coefficient
//
//	prior codes prepares ebx and ecx as follows:
//		ebx = L_Bits>>3
//		ecx = L_Bits
//

get_next_coefficient:
//  use dword load & bitswap to achieve big endian ordering
	mov 	eax, [esi+ebx]					// *** PROBABLE MALALIGNMENT ***
	 and 	ecx, 7							// shift value

	bswap	eax								// big endian order
											// *** NOT PAIRABLE ***

	shl 	eax, cl							// left justify buffer
											// *** NOT PAIRABLE ***
											// *** 4 CYCLES ***
 	
//  do table lookups
	mov 	ebx, eax						// ebx for major table
	 mov 	ecx, eax						// ecx for minor table

	shr 	ebx, 24							// major table lookup

	shr 	ecx, 17							// minor table lookup in bits with garbage
	 mov 	ebx, [gTAB_TCOEFF_MAJOR+4*ebx]	// get the major table value
											// ** AGI **

	shr 	ebx, 1							// test major hit ?
	 jnc 	skipb							// if hit major

	and 	ecx, 0ffch						// mask off garbage for minor table
	 test 	ebx, ebx						// escape code value was 0x00000001

	jz 		escape_code						// handle escape by major table.

	mov 	ebx, [gTAB_TCOEFF_MINOR+ecx]	// use minor table
											 
//
//  input is ebx = event.  See function header for the meaning of its fields
//  now we decode the event, extracting the run, value, last.
//  The table value moves to ecx and is shifted downward as portions
//  are extracted to ebx. 
//
skipb:	
	mov 	ecx, ebx						// ecx = table value
	 and 	ebx, 0ffh						// ebx = 2*abs(level) + sign

	shr 	ecx, 8							// run to bottom
	 mov 	edx, [L_Quantizer64]			// edx = 64*quant

											//  ** PREFIX DELAY **
											//  ** AGI **
	mov 	ax, [gTAB_INVERSE_Q+edx+2*ebx]	// ax = dequantized value (I16)
	 mov 	ebx, ecx						// ebx = table value

	shl 	eax, 16							// shift value until sign bit is on top
	 and 	ebx, 0ffh						// ebx = run + 1

	sar 	eax, 16							// arithmetic shift extends value's sign
	 mov 	edx, [L_CumRun]					// edx = (old) cumulative run

	add 	edx, ebx						// cumulative run += run + 1
	 mov 	[edi], eax						// save coefficient's signed value

	cmp 	edx, 03fh						// check run for bitstream error
	 jg 	error

	mov 	[L_CumRun], edx					// update the cumulative run
	 inc 	ebp								// increment number of coefficients read

											//  ** AGI **
	mov 	edx, [gTAB_ZZ_RUN+4*edx]		// edx = index of the current coefficient
 	 mov 	ebx, ecx						// ebx:  bit 8 = last flag

	mov 	[edi+4], edx					// save coefficient's index
	 add 	edi, 8							// increment coefficient pointer

	shr 	ecx, 9							// ecx = bits decoded
 	 mov 	edx, [L_Bits]					// edx = L_Bits

	add 	ecx, edx						// L_Bits += bits decoded
	 mov 	edx, ebx						// ebx:  bit 8 = last flag

	mov 	[L_Bits], ecx					// update L_Bits
	 mov 	ebx, ecx						// ebx = L_Bits

	shr 	ebx, 3							// offset for bitstream load
	 test	edx, 100h						// check for last

	jz  	get_next_coefficient	 	
			

finish:
	mov 	ecx, [P_num]   					// pointer to number of coeffients read
	 mov 	eax, [L_Bits]					// return total bits used

	pop 	ebx								
	 pop 	edi

	mov 	[ecx], ebp						// store number of coefficients read
	 pop 	esi

	pop 	ebp
	 ret


//
// process escape code separately
//
//	we have the following 4 cases to compute the reconstructed value
//	depending on the sign of L=level and the parity of Q=quantizer:
//
//				L pos		L neg
//	Q even		2QL+(Q-1)	2QL-(Q-1)
//	Q odd		2QL+(Q)		2QL-(Q)
//
//	The Q or Q-1 term is formed by adding Q to its parity bit 
//	and then subtracting 1.
//	The + or - on this term is gotten by anding the term with a
//	mask (=0 or =-1) formed from the sign bit of Q*L,
//	doubling the result, then subtracting it from the term.
//	This will negate the term when L is negative and leave
//	it unchanged when L is positive.
//	
//	Register usages:
//		eax		starts with bitstream, later L, finally result
//		ebx		starts with Q, later is the Q or Q-1 term
//		ecx		startw with mask, later 2*term
//		edx		bitstream
//
escape_code:								
	mov 	edx, eax						// edx = bitstream buffer

	shl 	eax, 14							// signed 8-bit level to top

	sar 	eax, 24							// eax = L (signed level)
	 mov 	ebx, [L_Quantizer]

	test	eax, 7fh						// test for invalid codes
	 jz  	error

	imul	eax, ebx						// eax = Q*L
											// *** NOT PAIRABLE ***
											// *** 10 cycles ***

	dec 	ebx								// term = Q-1
	 mov 	ecx, eax						// mask = QL

	or  	ebx, 1							// term = Q-1 if Q even, else = Q
	 sar 	ecx, 31							// mask = -1 if L neg, else = 0

	xor 	ebx, ecx						// term = ~Q[-1] if L neg, else = Q[-1]
	 add 	eax, eax						// result = 2*Q*L

	sub 	ebx, ecx						// term = -(Q[-1]) if L neg, else = Q[-1]
	 mov 	ecx, edx						// bitstream to ecx to get run

	add 	eax, ebx						// result = 2QL +- Q[-1]

//  now clip to -2048 ... +2047 (12 bits:  0xfffff800 <= res <= 0x000007ff)
	cmp 	eax, -2048
	 jge 	skip1

	mov 	eax, -2048
	 jmp	skip2

skip1:
	cmp 	eax, +2047
	 jle  	skip2

	mov 	eax, 2047

skip2:
//  update run and compute index

	shr 	ecx, 18							// run to bottom
 	 mov 	ebx, [L_CumRun]					// ebx = old total run

	and 	ecx, 3fh						// mask off bottom 6 bits for run
	 inc 	ebx								// old run ++

	add 	ebx, ecx						// ebx = new cumulative run
 	 mov 	[edi], eax						// save coefficient's signed value

	cmp 	ebx, 03fh						// check run for bitstream error
	 jg 	error

  	mov 	[L_CumRun], ebx					// update the cumulative run
	 mov 	ecx, [L_Bits]					// ebx = number of bits used

	mov 	ebx, [gTAB_ZZ_RUN+4*ebx]		// ebx = index of the current coefficient
	add 	ecx, 22							// escape code uses 22 bits

	mov 	[edi+4], ebx					// save coefficient's index
	 add 	edi, 8							// increment coefficient pointer

	mov 	[L_Bits], ecx					// update number of bits used
 	 mov 	ebx, ecx						// ebx = L_Bits

	shr 	ebx, 3							// offset for bitstream load
	 inc 	ebp								// increment number of coefficients read

	test 	edx, 01000000h					// check last bit
	 jz  	get_next_coefficient	 	

	jmp 	finish

				
error:
	pop		ebx								
	 pop 	edi

	pop		esi
	 pop 	ebp

	xor 	eax, eax						// zero bits used indicates ERROR
	 ret

 }

}
#pragma code_seg()