/* *************************************************************************
**    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.
**    Copyright (c) 1996 Intel Corporation.
**    All Rights Reserved.
**
** *************************************************************************
*/
// $Author:   CZHU  $
// $Date:   06 Feb 1997 15:35:30  $
// $Archive:   S:\h26x\src\dec\d3mvdec.cpv  $
// $Header:   S:\h26x\src\dec\d3mvdec.cpv   1.47   06 Feb 1997 15:35:30   CZHU  $
// $Log:   S:\h26x\src\dec\d3mvdec.cpv  $
// 
//    Rev 1.47   06 Feb 1997 15:35:30   CZHU
// Changed | to ||
// 
//    Rev 1.46   24 Jan 1997 13:32:56   CZHU
// 
// Added fix to check uBitsReady when return from DecodingMB header for 
// packet loss detection.
// 
//    Rev 1.45   19 Dec 1996 16:07:44   JMCVEIGH
// 
// Added initialization of forward-prediction-only flag if a block
// is not coded. This is used in H.263+ only.
// 
//    Rev 1.44   16 Dec 1996 17:44:00   JMCVEIGH
// Allow 8x8 motion vectors if deblocking filter selected and
// support for decoding of improved PB-frame MODB.
// 
//    Rev 1.43   20 Oct 1996 15:51:06   AGUPTA2
// Adjusted DbgLog trace levels; 4:Frame, 5:GOB, 6:MB, 8:everything
// 
//    Rev 1.42   20 Oct 1996 13:21:20   AGUPTA2
// Changed DBOUT into DbgLog.  ASSERT is not changed to DbgAssert.
// 
// 
//    Rev 1.41   11 Jul 1996 15:13:16   AGUPTA2
// Changed assertion failures into errors when decoder goes past end of 
// the bitstream.
// 
//    Rev 1.40   03 May 1996 13:05:34   CZHU
// 
// Check errors at MB header for packet faults and return PACKET_FAULT
// 
//    Rev 1.39   22 Mar 1996 17:25:18   AGUPTA2
// Changes to accomodate MMX rtns.
// 
//    Rev 1.38   08 Mar 1996 16:46:28   AGUPTA2
// Added pragmas code_seg and data_seg.  Changed the size of some of local data.
// 
// 
//    Rev 1.37   23 Feb 1996 09:46:56   KLILLEVO
// fixed decoding of Unrestricted Motion Vector mode
// 
//    Rev 1.36   17 Jan 1996 12:44:26   RMCKENZX
// Added support for decoding motion vectors for UMV
// Reorganized motion vector decoding processes, especially
// for AP and eliminating the large HALF_PEL conversion tables.
// 
//    Rev 1.35   02 Jan 1996 17:55:50   RMCKENZX
// 
// Updated copyright notice
// 
//    Rev 1.34   02 Jan 1996 15:48:54   RMCKENZX
// Added code to preserve the Block Type in the block action stream
// for P blocks when PB frames is on.  This is read in H263IDCTandMC
// when AP is on.
// 
//    Rev 1.33   18 Dec 1995 12:42:12   RMCKENZX
// added copyright notice
// 
//    Rev 1.32   13 Dec 1995 22:10:06   RHAZRA
// AP bug fix
// 
//    Rev 1.31   13 Dec 1995 22:01:26   TRGARDOS
// 
// Added more parentheses to a logical statement.
// 
//    Rev 1.30   13 Dec 1995 15:10:08   TRGARDOS
// Changed MV assert to be -32 <= MV <= 31, instead of strict
// inequalities.
// 
//    Rev 1.29   13 Dec 1995 10:59:58   RHAZRA
// 
// AP+PB changes
// 
//    Rev 1.28   11 Dec 1995 11:34:20   RHAZRA
// 12-10-95 changes: added AP stuff
// 
//    Rev 1.27   09 Dec 1995 17:28:38   RMCKENZX
// Gutted and re-built file to support decoder re-architecture.
// New modules are:
// H263ComputeMotionVectors
// H263DecodeMBHeader
// H263DecodeIDCTCoeffs
// This module now contains code to support the first pass of the decoder
// 
//    Rev 1.26   05 Dec 1995 09:12:28   CZHU
// Added fixes for proper MV prediction when GOB header is present
// 
//    Rev 1.25   22 Nov 1995 13:43:42   RMCKENZX
// 
// changed calls to utilize assembly modules for bi-directional
// motion compensation & removed corresponding C modules
// 
//    Rev 1.24   17 Nov 1995 12:58:22   RMCKENZX
// added missing ()s to adjusted_mvx & adjusted_mvy in H263BiMotionCompLuma
// 
//    Rev 1.23   07 Nov 1995 11:01:10   CZHU
// Include Fixes for boundary of bi-directional predictions
// 
//    Rev 1.22   26 Oct 1995 11:22:10   CZHU
// Compute backward MV based on TRD, not TR
// 
//    Rev 1.21   13 Oct 1995 16:06:22   CZHU
// First version that supports PB frames. Display B or P frames under
// VfW for now. 
// 
//    Rev 1.20   13 Oct 1995 13:42:46   CZHU
// Added back the #define for debug messages.
// 
//    Rev 1.19   11 Oct 1995 17:51:00   CZHU
// 
// Fixed bugs in passing MV back with DC.
// 
//    Rev 1.18   11 Oct 1995 13:26:08   CZHU
// Added code to support PB frame
// 
//    Rev 1.17   09 Oct 1995 09:44:04   CZHU
// 
// Use the optimized version of (half,half) interpolation
// 
//    Rev 1.16   08 Oct 1995 13:45:10   CZHU
// 
// Optionally use C version of interpolation
// 
//    Rev 1.15   03 Oct 1995 15:05:26   CZHU
// Cleaning up.
// 
//    Rev 1.14   02 Oct 1995 09:58:56   TRGARDOS
// Added #ifdef to debug print statement.
// 
//    Rev 1.13   29 Sep 1995 16:22:06   CZHU
// 
// Fixed the bug in GOB 0 when compute MV2
// 
//    Rev 1.12   29 Sep 1995 09:02:56   CZHU
// Rearrange Chroma blocks processing
// 
//    Rev 1.11   28 Sep 1995 15:33:04   CZHU
// 
// Call the right version of interpolation based on MV
// 
//    Rev 1.10   27 Sep 1995 11:54:50   CZHU
// Integrated half pel motion compensation
// 
//    Rev 1.9   26 Sep 1995 15:33:06   CZHU
// 
// Put place holder in for half pel interpolation
// 
//    Rev 1.8   20 Sep 1995 14:47:50   CZHU
// Made the number of MBs in GOB a variableD
// 
//    Rev 1.7   19 Sep 1995 13:53:34   CZHU
// Added assertion for half-pel motion vectors
// 
//    Rev 1.6   18 Sep 1995 10:20:58   CZHU
// Scale the motion vectors for UV planes too. 
// 
//    Rev 1.5   14 Sep 1995 10:12:36   CZHU
// 
// Cleaning
// 
//    Rev 1.4   13 Sep 1995 11:56:30   CZHU
// Fixed bugs in finding the predictors for motion vector.
// 
//    Rev 1.3   12 Sep 1995 18:18:58   CZHU
// 
// Modified table for looking up UV MV's
// 
//    Rev 1.2   11 Sep 1995 16:41:14   CZHU
// Added reference block address calculation
// 
//    Rev 1.1   11 Sep 1995 14:31:30   CZHU
// Started to add function to calculate MVs and Reference block addresses.
// 
//    Rev 1.0   08 Sep 1995 11:45:56   CZHU
// Initial revision.

#include "precomp.h"

/* MCBPC table format
 *
 * layout     
 *
 *     unused   mbtype  cbpc  bits
 *     15-13   	12-10   9-8   7-0
 */
#pragma data_seg("IADATA1")

#define MCBPC_MBTYPE(d) ((d>>10) & 0x7)
#define MCBPC_CBPC(d) ((d>>8) & 0x3)
#define MCBPC_BITS(d) (d & 0xFF)
#define MCBPC_ENTRY(m,c,b) \
	( ((m & 0x7) <<10) | ((c & 0x3) << 8) | (b & 0xFF) )

U16 gNewTAB_MCBPC_INTRA[64] = {
	/* index 8 - stuffing */
	MCBPC_ENTRY(0,0,9),
	/* index 5 */ 
	MCBPC_ENTRY(4,1,6),
	/* index 6 */ 
	MCBPC_ENTRY(4,2,6),
	/* index 7 */ 
	MCBPC_ENTRY(4,3,6), 

	/* index 4; 0001XX */
	MCBPC_ENTRY(4,0,4), MCBPC_ENTRY(4,0,4), MCBPC_ENTRY(4,0,4), MCBPC_ENTRY(4,0,4),

	/* index 1; 001XXX */
	MCBPC_ENTRY(3,1,3), MCBPC_ENTRY(3,1,3),	MCBPC_ENTRY(3,1,3),	MCBPC_ENTRY(3,1,3),
	MCBPC_ENTRY(3,1,3),	MCBPC_ENTRY(3,1,3),	MCBPC_ENTRY(3,1,3),	MCBPC_ENTRY(3,1,3),

	/* index 2; 010XXX */
	MCBPC_ENTRY(3,2,3), MCBPC_ENTRY(3,2,3), MCBPC_ENTRY(3,2,3),	MCBPC_ENTRY(3,2,3),
	MCBPC_ENTRY(3,2,3),	MCBPC_ENTRY(3,2,3),	MCBPC_ENTRY(3,2,3),	MCBPC_ENTRY(3,2,3),

	/* index 3; 011XXX */
	MCBPC_ENTRY(3,3,3), MCBPC_ENTRY(3,3,3),	MCBPC_ENTRY(3,3,3),	MCBPC_ENTRY(3,3,3),
	MCBPC_ENTRY(3,3,3),	MCBPC_ENTRY(3,3,3),	MCBPC_ENTRY(3,3,3),	MCBPC_ENTRY(3,3,3),

	/* index 0; 1XXXXX */
	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 
	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 

	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 
	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 

	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 
	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 

	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1), 
	MCBPC_ENTRY(3,0,1), MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1),	MCBPC_ENTRY(3,0,1) 
};

/* MCBPC table for INTER frame
 *
 * Format same as MCBPC for INTRA
 * layout     
 *
 *     unused   mbtype  cbpc  bits
 *     15-13   	12-10   9-8   7-0 
 *
 */

U16 gNewTAB_MCBPC_INTER[512] = {
	/* invalid code */
	MCBPC_ENTRY(0,0,0),
	MCBPC_ENTRY(0,0,9), //index 20, stuffing
	MCBPC_ENTRY(4,3,9), //19,
	MCBPC_ENTRY(4,2,9), //18
	MCBPC_ENTRY(4,1,9), //17
	MCBPC_ENTRY(1,3,9), //7
	//2 index 14
	MCBPC_ENTRY(3,2,8),MCBPC_ENTRY(3,2,8), //14
	//2 index 13
	MCBPC_ENTRY(3,1,8),MCBPC_ENTRY(3,1,8), //13
	//2 index 11
	MCBPC_ENTRY(2,3,8),MCBPC_ENTRY(2,3,8), //11
	//4 index 15
	MCBPC_ENTRY(3,3,7),MCBPC_ENTRY(3,3,7),MCBPC_ENTRY(3,3,7),MCBPC_ENTRY(3,3,7), //15
	//4 index 10
	MCBPC_ENTRY(2,2,7),MCBPC_ENTRY(2,2,7),MCBPC_ENTRY(2,2,7),MCBPC_ENTRY(2,2,7), //10
	//4 index 9
	MCBPC_ENTRY(2,1,7),MCBPC_ENTRY(2,1,7),MCBPC_ENTRY(2,1,7),MCBPC_ENTRY(2,1,7), //9
	//4 index 6
	MCBPC_ENTRY(1,2,7),MCBPC_ENTRY(1,2,7),MCBPC_ENTRY(1,2,7),MCBPC_ENTRY(1,2,7), //6
	//4 index 5
	MCBPC_ENTRY(1,1,7),MCBPC_ENTRY(1,1,7),MCBPC_ENTRY(1,1,7),MCBPC_ENTRY(1,1,7), //5
	//8 index 16
	MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),//16
	MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),MCBPC_ENTRY(4,0,6),
	//8 index 3
	MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),//3
	MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),MCBPC_ENTRY(0,3,6),//3
	//16 index 12
	MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),//12
	MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),
	MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),
	MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),MCBPC_ENTRY(3,0,5),
	//32 INDEX 2
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),
	MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),MCBPC_ENTRY(0,2,4),

	//32 index 1
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
	MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),MCBPC_ENTRY(0,1,4),
 

	//64 index 8
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),

	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),
	MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),MCBPC_ENTRY(2,0,3),



	//64 index 4
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),

	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),
	MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),MCBPC_ENTRY(1,0,3),


	//256 index 0
	//0--63
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	//64--127
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	//128--128+64=192
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	//192--255
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),
	MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1),MCBPC_ENTRY(0,0,1)
};

/* CBPY table format
 *
 * layout     
 *
 *     intra  inter  bits
 *     15-12  11-8   7-0
 *
 * unused entries should have zero data
 */
#define CBPY_INTRA(d) ((d>>12) & 0xf)
#define CBPY_INTER(d) ((d>>8) & 0xf)
#define CBPY_BITS(d) (d & 0xff)
#define CBPY_ENTRY(a,r,b) \
	( ((a & 0xf) <<12) | ((r & 0xf) << 8) | (b & 0xFF) )
#define CBPY_NOT_USED() CBPY_ENTRY(0,0,0)

U16 gNewTAB_CBPY[64] = {
	/* NotUsed - 0000 0X */
	CBPY_NOT_USED(), CBPY_NOT_USED(),

	/* Index 6 - 0000 10 */
	CBPY_ENTRY(6,9,6),

	/* Index 9 - 0000 11 */
	CBPY_ENTRY(9,6,6),

	/* Index 8 - 0001 0x */
	CBPY_ENTRY(8,7,5), CBPY_ENTRY(8,7,5),

	/* Index 4 - 0001 1x */
	CBPY_ENTRY(4,11,5),	CBPY_ENTRY(4,11,5),

	/* Index 2 - 0010 0x */
	CBPY_ENTRY(2,13,5),	CBPY_ENTRY(2,13,5),

	/* Index 1 - 0010 1x */
	CBPY_ENTRY(1,14,5),	CBPY_ENTRY(1,14,5),

	/* Index 0 - 0011 xx */
	CBPY_ENTRY(0,15,4),	CBPY_ENTRY(0,15,4), CBPY_ENTRY(0,15,4), CBPY_ENTRY(0,15,4),

	/* Index 12- 0100 xx */
	CBPY_ENTRY(12,3,4),	CBPY_ENTRY(12,3,4), CBPY_ENTRY(12,3,4), CBPY_ENTRY(12,3,4),

	/* Index 10- 0101 xx */
	CBPY_ENTRY(10,5,4),	CBPY_ENTRY(10,5,4), CBPY_ENTRY(10,5,4), CBPY_ENTRY(10,5,4),

	/* Index 14- 0110 xx */
	CBPY_ENTRY(14,1,4),	CBPY_ENTRY(14,1,4), CBPY_ENTRY(14,1,4), CBPY_ENTRY(14,1,4),

	/* Index 5 - 0111 xx */
	CBPY_ENTRY(5,10,4), CBPY_ENTRY(5,10,4), CBPY_ENTRY(5,10,4), CBPY_ENTRY(5,10,4),

	/* Index 13- 1000 xx */
	CBPY_ENTRY(13,2,4),	CBPY_ENTRY(13,2,4),	CBPY_ENTRY(13,2,4),	CBPY_ENTRY(13,2,4),

	/* Index 3 - 1001 xx */
	CBPY_ENTRY(3,12,4),	CBPY_ENTRY(3,12,4),	CBPY_ENTRY(3,12,4),	CBPY_ENTRY(3,12,4),

	/* Index 11- 1010 xx */
	CBPY_ENTRY(11,4,4),	CBPY_ENTRY(11,4,4),	CBPY_ENTRY(11,4,4),	CBPY_ENTRY(11,4,4),

	/* Index 7 - 1011 xx */
	CBPY_ENTRY(7,8,4),	CBPY_ENTRY(7,8,4), CBPY_ENTRY(7,8,4), CBPY_ENTRY(7,8,4),

	/* Index 15- 11xx xx */
	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),
	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),
	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),
	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2),	CBPY_ENTRY(15,0,2)
};

I16 gNewTAB_DQUANT[4] = { -1, -2, 1, 2 };

#ifdef USE_MMX // { USE_MMX
T_pFunc_VLD_RLD_IQ_Block pFunc_VLD_RLD_IQ_Block[2] = {VLD_RLD_IQ_Block, MMX_VLD_RLD_IQ_Block};
#endif // } USE_MMX

#pragma data_seg(".data")
/*****************************************************************************
 *
 *  H263DecodeMBHeader
 *
 *  Decode the MB header
 */
#pragma code_seg("IACODE1")
I32 H263DecodeMBHeader(
	T_H263DecoderCatalog FAR * DC, 														  
	BITSTREAM_STATE FAR * fpbsState,
	U32                     **pN,
	T_MBInfo FAR * fpMBInfo)
{
	I32 iReturn = ICERR_ERROR;
	U8 FAR * fpu8;
	U32 uBitsReady;
	U32 uWork;
	U32 uResult;
	U32 uCode;
	U32 uBitCount;
	U32 uMBType;
	U32 bCoded;
	U32 bStuffing;
	U32 bGetCBPB;
	U32 bGetMVDB;
	U32 i;

	FX_ENTRY("H263DecodeMBHeader");

	GET_BITS_RESTORE_STATE(fpu8, uWork, uBitsReady, fpbsState)

	// COD -----------------------------------------------------
ReadCOD:
	if (! DC->bKeyFrame) 
	{
		GET_ONE_BIT(fpu8, uWork, uBitsReady, uResult);
		bCoded = !uResult; /* coded when bit is set to zero */
	} 
	else
		bCoded = 1;
	DC->bCoded = (U16) bCoded;

	if (!bCoded) 
	{
		/* when a block is not coded, "the remaining part of the macroblock
		 * layer is empty; in that case the decoder shall treat the macroblock
		 * as in INTER block with motion vector for the whole block equal to 
		 * zero and with no coefficient data" (5.3.1 p 16).
		 */
		DC->uMBType = 0;

		fpMBInfo->i8MBType = 0;       // AP-NEW

		DC->uCBPC = 0;
		DC->uCBPY = 0;

		/* Now update the pN array. Since the block is not coded, write 0
		 *  for all blocks in the macroblock.
		 */
		if (DC->bPBFrame) 
		{	 // 12 blocks for a PB frame
			fpMBInfo->i8MVDBx2 = fpMBInfo->i8MVDBy2 = 0;
			for (i=0; i<12; i++)
			{ // PB-NEW
				**pN = 0;
				(*pN)++;
			}
		}
		else 
		{  // only 6 blocks for non PB frame
			for (i=0; i<6; i++)
			{ // NEW
				**pN = 0;
				(*pN)++;
			}
		}

#ifdef H263P
		// If block is not coded, we use the original PB-frame method in Annex G.
		// In other words, use bidirectional prediction (not forward only)
		fpMBInfo->bForwardPredOnly = FALSE;		 
#endif

		GET_BITS_SAVE_STATE(fpu8, uWork, uBitsReady, fpbsState)
		iReturn = ICERR_OK;
		goto done;
	}

	//  MCBPC ---------------------------------------------------
	bStuffing = 0;
	if (DC->bKeyFrame) 
	{
		GET_VARIABLE_BITS(6, fpu8, uWork, uBitsReady, uResult, 
						  uCode, uBitCount, gNewTAB_MCBPC_INTRA);
		if (uCode == 0) 
		{
			/* start of the stuffing code - read the next 3-bits
			*/
			GET_FIXED_BITS(3, fpu8, uWork, uBitsReady, uResult);
			if (uResult == 1)
				bStuffing = 1;
			else 
			{
				ERRORMESSAGE(("%s: Incorrect key frame stuffing bits!\r\n", _fx_));
				//#ifdef LOSS_RECOVERY
// Always True				if (uBitsReady <0) uBitsReady += 9;//trick and trap, do not change it without consulting Chad
				GET_BITS_SAVE_STATE(fpu8, uWork, uBitsReady, fpbsState)
				iReturn = PACKET_FAULT;
				//#else
				//			    iReturn = ICERR_ERROR;
				//#endif
				goto done;
			}
		}
	} 
	else 
	{
		//  Delta Frame
		//  mcpbc, VLD
		GET_VARIABLE_BITS(9, fpu8, uWork, uBitsReady, uResult, 
		uCode, uBitCount, gNewTAB_MCBPC_INTER);

		if (uCode == 1) 
			bStuffing = 1;
		//#ifdef LOSS_RECOVERY
		else if (uCode == 0)	   //catch the illegal code
		{
			ERRORMESSAGE(("%s: Incorrect stuffing bits!\r\n", _fx_));
// Always True			if (uBitsReady <0) uBitsReady += 9;//trick and trap, do not change it without consulting Chad
			GET_BITS_SAVE_STATE(fpu8, uWork, uBitsReady, fpbsState)
			iReturn = PACKET_FAULT;
			goto done;
		}
		//#endif

	}

	/*  When MCBPC==Stuffing, the remaining part of the macroblock layer is
	*  skipped and the macroblock number is not incremented (5.3.2 p18)"
	*  We support this by jumping to the start - to look for COD 
	*/
	if (bStuffing)
		goto ReadCOD;

	uMBType = MCBPC_MBTYPE(uResult);
	if (DC->bKeyFrame && (uMBType != 3 && uMBType != 4)) 
	{
		ERRORMESSAGE(("%s: Bad key frame MBType!\r\n", _fx_));
		iReturn = ICERR_ERROR;
		goto done;
	}

	DC->uMBType = uMBType;

	fpMBInfo->i8MBType = (I8) uMBType;

	DC->uCBPC = MCBPC_CBPC(uResult);

	//  MODB ----------------------------------------------------
	bGetCBPB = 0;
	bGetMVDB = 0;

	if (DC->bPBFrame) 
    {
	    ASSERT( !DC->bKeyFrame);

#ifdef H263P
		// Default is to use original PB-frame method in Annex G.
		fpMBInfo->bForwardPredOnly = FALSE;		 

		if (DC->bImprovedPBFrames)
		{
			// See modified TABLE 8/H.263, Annex M, document LBC-96-358
			GET_FIXED_BITS(1, fpu8, uWork, uBitsReady, uResult);
			if (uResult)
			{
				// 1xx
				GET_FIXED_BITS(1, fpu8, uWork, uBitsReady, uResult);
				bGetCBPB = uResult;
				if (!uResult) 
					// 10x
					bGetMVDB = 1;
				else 
				{
					// 11x
					GET_FIXED_BITS(1, fpu8, uWork, uBitsReady, uResult);
					bGetMVDB = !uResult;
				}
			}
			if (bGetMVDB)
				// B-block is forward predicted (otherwise it is bidirectionally predicted)
				fpMBInfo->bForwardPredOnly = TRUE;		 
		}
		else 
#endif // H263P
		{
			GET_FIXED_BITS(1, fpu8, uWork, uBitsReady, uResult);
			bGetCBPB = uResult;			// see section 5.3.3 table 7/H.263
			if (bGetCBPB) 
			{
				bGetMVDB = 1;
				GET_FIXED_BITS(1, fpu8, uWork, uBitsReady, uResult);
				bGetCBPB = uResult;
			}
		}
	} 

	// CBPB ----------------------------------------------------
	DC->u8CBPB = 0;
	if (bGetCBPB) 
	{
		ASSERT(!DC->bKeyFrame);
		GET_FIXED_BITS(6, fpu8, uWork, uBitsReady, uResult);
		DC->u8CBPB = (U8)uResult;
	}

	// CBPY ----------------------------------------------------
	GET_VARIABLE_BITS(6, fpu8, uWork, uBitsReady, uResult, 
					  uCode, uBitCount, gNewTAB_CBPY);
	if (uResult == 0) 
	{
		ERRORMESSAGE(("%s:  Undefined CBPY variable code!\r\n", _fx_));
		iReturn = ICERR_ERROR;
		goto done;
	}
	if (DC->uMBType > 2)		//INTRA MB, not intra frame
		DC->uCBPY = CBPY_INTRA(uResult); 
	else
		DC->uCBPY = CBPY_INTER(uResult);

	// DQUANT --------------------------------------------------
	if (DC->uMBType == 1 || DC->uMBType == 4) 
	{
		GET_FIXED_BITS(2, fpu8, uWork, uBitsReady, uResult);
		DC->uDQuant = gNewTAB_DQUANT[uResult];
		DC->uGQuant += DC->uDQuant;
		DC->uPQuant =  DC->uGQuant;
	} else
		DC->uDQuant = 0;

	DEBUGMSG(ZONE_DECODE_MB_HEADER, ("  %s: MBType = %ld, MCBPC = 0x%lX, CBPY = 0x%lX, DQuant = 0x%lX\r\n", _fx_, DC->uMBType, DC->uCBPC, DC->uCBPY, DC->uDQuant));

	// MVD -----------------------------------------------------
	DC->i8MVDx2=DC->i8MVDy2=0;	 //Zero init it anyway.

	if ( DC->bPBFrame || DC->uMBType <= 2) 
	{
	    GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Undefined Motion Vector code!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVDx2 = (I8)(uResult>>8);

	    GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVDy2 = (I8)(uResult>>8);
	}

	// MVD 2-4 -------------------------------------------------
#ifdef H263P
	// In H.263+, 8x8 motion vectors are possible if the deblocking
	// filter is selected.
	if ((DC->bAdvancedPrediction || DC->bDeblockingFilter)
		&& (DC->uMBType == 2) ) 
#else
	if (DC->bAdvancedPrediction && (DC->uMBType == 2) ) 
#endif
	{
		DC->i8MVD2x2 = DC->i8MVD2y2 = 0;

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD2x2 = (I8)(uResult>>8);

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD2y2 = (I8)(uResult>>8);

		DC->i8MVD3x2 = DC->i8MVD3y2 = 0;

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD3x2 = (I8)(uResult>>8);

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD3y2 = (I8)(uResult>>8);

		DC->i8MVD4x2 = DC->i8MVD4y2 = 0;

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD4x2 = (I8)(uResult>>8);

		GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Block Motion Vector VLC!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		DC->i8MVD4y2 = (I8)(uResult>>8);

		DEBUGMSG(ZONE_DECODE_MB_HEADER, ("  %s: MVD2x2 = %d, MVD2y2 = %d, MVD3x2 = %d, MVD3y2 = %d, MVD4x2 = %d, MVD4y2 = %d\r\n", _fx_, DC->i8MVD2x2, DC->i8MVD2y2, DC->i8MVD3x2, DC->i8MVD3y2, DC->i8MVD4x2, DC->i8MVD4y2));
	}

	// MVDB ----------------------------------------------------
	DC->i8MVDBx2 = DC->i8MVDBy2 = 0;	 //Zero init it anyway.
	fpMBInfo->i8MVDBx2 = fpMBInfo->i8MVDBy2 = 0;
	if (bGetMVDB) 
	{
		ASSERT(DC->bPBFrame);
		ASSERT(!DC->bKeyFrame);
        GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Motion Vector MVDB!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		fpMBInfo->i8MVDBx2 = DC->i8MVDBx2 = (I8)(uResult>>8);

	    GET_VARIABLE_BITS_MV(13, fpu8, uWork, uBitsReady, uResult,uCode, 
                             uBitCount, gTAB_MVD_MAJOR, gTAB_MVD_MINOR);
		if (!uResult) 
		{
			ERRORMESSAGE(("%s:  Bad Motion Vector MVDB!\r\n", _fx_));
			iReturn = ICERR_ERROR;
			goto done;
		}
		fpMBInfo->i8MVDBy2 = DC->i8MVDBy2 = (I8)(uResult>>8);
	}

	GET_BITS_SAVE_STATE(fpu8, uWork, uBitsReady, fpbsState)

	iReturn = ICERR_OK;

done:
	return iReturn;
} /* end H263DecodeMBHeader() */
#pragma code_seg()


/*****************************************************************************
 *
 *  H263DecodeIDCTCoeffs
 *
 *  Decode each of the blocks in this macro block
 */
#pragma code_seg("IACODE1")
I32 H263DecodeIDCTCoeffs(
	T_H263DecoderCatalog FAR * DC,
	T_BlkAction FAR * fpBlockAction, 
	U32 uBlockNumber,
	BITSTREAM_STATE FAR * fpbsState,
	U8 FAR * fpu8MaxPtr,
	U32 **pN,                           // NEW
	T_IQ_INDEX **pRUN_INVERSE_Q)        // NEW
{
	I32 iResult = ICERR_ERROR;
	int iBlockPattern;
	int i;
	U8 u8PBlkType;
	U32 uBitsReady;
	U32 uBitsReadIn;
	U32 uBitsReadOut;
	U8  u8Quant;				// quantization level for this Mblock 
	U8 FAR * fpu8;
	U32 uByteCnt;
	T_BlkAction FAR * pActionStream;
#ifdef USE_MMX // { USE_MMX
    T_pFunc_VLD_RLD_IQ_Block pFunc_VLD = pFunc_VLD_RLD_IQ_Block[DC->bMMXDecoder];
#else // }{ USE_MMX
    T_pFunc_VLD_RLD_IQ_Block pFunc_VLD = VLD_RLD_IQ_Block;
#endif // } USE_MMX

	pActionStream = fpBlockAction;

	FX_ENTRY("H263DecodeIDCTCoeffs");

	/* On input the pointer points to the next byte.  We need to change it to 
	 * point to the current word on a 32-bit boundary.  
	 */

	fpu8 = fpbsState->fpu8 - 1;				/* point to the current byte */
	uBitsReady = fpbsState->uBitsReady;

	while (uBitsReady >= 8) 
	{
		fpu8--;
		uBitsReady -= 8;
	}

	uBitsReadIn = 8 - uBitsReady;
	u8Quant = (U8) (DC->uGQuant); 	

	if ( (DC->bPBFrame) || ((!DC->bKeyFrame) && (DC->uMBType <= 2))) 
	{
		// calculate motion vectors for the 6 blocks in this MB
		iResult = H263ComputeMotionVectors(DC, fpBlockAction);         // NEW

		if (iResult != ICERR_OK) 
		{ 
			ERRORMESSAGE(("%s: Error decoding MV!\r\n", _fx_));
			goto done;
		}

	} // endif PB or (inter and not key)

    // create block pattern from CBPY & CBPC
    iBlockPattern = ( (int) DC->uCBPY ) << 2;
    iBlockPattern |=  (int) DC->uCBPC;

	// Decode all 6 blocks up to, but not including, IDCT.
	for (i=0; i<6; i++) 
	{
		if (iBlockPattern & 0x20) 
		{
			if (DC->uMBType >= 3)  
				fpBlockAction->u8BlkType = BT_INTRA;
			else
				fpBlockAction->u8BlkType = BT_INTER;
		}
		else 
		{
			if (DC->uMBType >= 3)  
				fpBlockAction->u8BlkType = BT_INTRA_DC;
			else
				fpBlockAction->u8BlkType = BT_EMPTY;
		}

		if (fpBlockAction->u8BlkType != BT_EMPTY) 
		{
			fpBlockAction->u8Quant = u8Quant;
			ASSERT(fpBlockAction->pCurBlock != NULL);
			ASSERT(fpBlockAction->uBlkNumber == uBlockNumber);

			uBitsReadOut = (*pFunc_VLD)(
										fpBlockAction,
										fpu8,
										uBitsReadIn,
										(U32 *) *pN,
										(U32 *) *pRUN_INVERSE_Q);


			if (uBitsReadOut == 0) 
			{
				ERRORMESSAGE(("%s: Error decoding P block: VLD_RLD_IQ_Block return 0 bits read...\r\n", _fx_));
				goto done;
			}

			ASSERT( **pN < 65);		

			*pRUN_INVERSE_Q += **pN;                       // NEW
			if (fpBlockAction->u8BlkType != BT_INTER)      // NEW
				**pN += 65;								   // NEW
			(*pN)++;

			uByteCnt = uBitsReadOut >> 3; 		/* divide by 8 */
			uBitsReadIn = uBitsReadOut & 0x7; 	/* mod 8 */
			fpu8 += uByteCnt;      		

			//  allow the pointer to address up to four beyond the end - reading
			//  by DWORD using postincrement; otherwise we have bitstream error.
			if (fpu8 > fpu8MaxPtr+4)
				goto done;

			//  The test matrix includes the debug version of the driver.  The 
			//  following assertion creates a problem when testing with VideoPhone
			//  and so please do not check-in a version with the assertion 
			//  uncommented.
			// ASSERT(fpu8 <= fpu8MaxPtr+4);

		}
		else 
		{ // block type is empty 
			**pN = 0;	                // NEW
			(*pN)++;
		}

		fpBlockAction++;
		iBlockPattern <<= 1;
		uBlockNumber++;

	} // end for (i=0; i<6; i++)


	//--------------------------------------------------------------------
	//
	//      Now do the 6 B-blocks -- if needed
	//
	//--------------------------------------------------------------------
	if (DC->bPBFrame) 
	{ // we are doing PB frames
		fpBlockAction = pActionStream;    // recover the block action stream pointer
		uBlockNumber -= 6;
		iBlockPattern = (int) DC->u8CBPB; // block pattern
		u8Quant = (U8) ( DC->uPQuant * (5 + DC->uDBQuant) / 4 );
		if (u8Quant > 31) u8Quant = 31;
		if (u8Quant <  1) u8Quant =  1;

		// Decode all 6 blocks up to, but not including, IDCT.
		for (i=0; i<6; i++) 
		{
			// if the block is coded
            if (iBlockPattern & 0x20) {
				// preserve the block type of the P-frame block
				u8PBlkType = fpBlockAction->u8BlkType;

				fpBlockAction->u8BlkType = BT_INTER;
				fpBlockAction->u8Quant = u8Quant;

				ASSERT(fpBlockAction->pBBlock != NULL);
				ASSERT(fpBlockAction->uBlkNumber == uBlockNumber);

				uBitsReadOut = (*pFunc_VLD)(
											fpBlockAction,
											fpu8,
											uBitsReadIn,
											(U32 *) *pN,
											(U32 *) *pRUN_INVERSE_Q);

                if (uBitsReadOut == 0) {
					ERRORMESSAGE(("%s: Error decoding B block: VLD_RLD_IQ_Block return 0 bits read...\r\n", _fx_));
					goto done;
				}

				ASSERT( **pN < 65);			// no B-frame Intra blocks		
				*pRUN_INVERSE_Q += **pN;							// NEW
				(*pN)++;

				uByteCnt = uBitsReadOut >> 3; 		// divide by 8
				uBitsReadIn = uBitsReadOut & 0x7; 	// mod 8
				fpu8 += uByteCnt;      		

				// allow the pointer to address up to four beyond the 
				// end - reading  by DWORD using postincrement; otherwise we 
				// have bitstream error.
				if (fpu8 > fpu8MaxPtr+4)
					goto done;

				//  The test matrix includes the debug version of the driver.  
				//  The following assertion creates a problem when testing with
				// VideoPhone and so please do not check-in a version with the 
				// assertion uncommented.
				// ASSERT(fpu8 <= fpu8MaxPtr+4);

				// restore the block type of the P-frame block
				fpBlockAction->u8BlkType = u8PBlkType;

			}
			else 
			{ // block is not coded
				**pN = 0;	                // NEW
				(*pN)++;
			}  // end if block is coded ... else ...

			fpBlockAction++;
			iBlockPattern <<= 1;
			uBlockNumber++;

		} // end for (i=0; i<6; i++)

	}  // end if (DC->bPBFrame)


	/* restore the scanning pointers to point to the next byte and set the 
	 * uWork and uBitsReady values.
	 */

	while (uBitsReadIn > 8)
	{
		fpu8++;
		uBitsReadIn -= 8;
	}
	fpbsState->uBitsReady = 8 - uBitsReadIn;
	fpbsState->uWork = *fpu8++;	   /* store the data and point to next byte */
	fpbsState->uWork &= GetBitsMask[fpbsState->uBitsReady];
	fpbsState->fpu8 = fpu8; 

	iResult = ICERR_OK;

done:
	return iResult;

} /* END H263DecodeIDCTCoeffs() */
#pragma code_seg()

#pragma code_seg("IACODE1")
I32 H263ComputeMotionVectors(T_H263DecoderCatalog FAR * DC,
	                         T_BlkAction FAR * fpBlockAction)
	       
{ 
	I32 mvx1, mvy1, mvx2, mvy2, mvx3, mvy3;  //predictors
	// motion vector predictors for AP
	I32 mvxp[3], mvyp[3];
	// motion vector differences for AP
	I32 mvxd[4], mvyd[4];
	int iAbove;       // takes you up one GOB (-1 * # of blocks in a GOB)
	I32 iMBNum;
	I32 iMBOffset;
	I32  mvx, mvy, scratch;
	int i;
	I32 iNumberOfMBsPerGOB;	  //assume QCIF for Now
	BOOL bNoAbove, bNoRight, bUMV;

	const char QuarterPelRound[] = {0, 1, 0, 0};
    const char SixteenthPelRound[] = 
        {0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1};

	FX_ENTRY("H263ComputeMotionVectors");

	DEBUGMSG(ZONE_DECODE_COMPUTE_MOTION_VECTORS, ("   %s: MB# = %d, BlockNumber = %d, (MVDx2,MVDy2) = (%d, %d)\r\n", _fx_, fpBlockAction->uBlkNumber/6, fpBlockAction->uBlkNumber, DC->i8MVDx2, DC->i8MVDy2));

#ifdef _DEBUG
	if (DC->uMBType == 2)
	{
		DEBUGMSG(ZONE_DECODE_COMPUTE_MOTION_VECTORS, ("   %s: (MVD2x2,MVD2y2) = (%d, %d), (MVD3x2,MVD3y2) = (%d, %d), (MVD4x2,MVD4y2) = (%d, %d)\r\n", _fx_, DC->i8MVD2x2, DC->i8MVD2y2, DC->i8MVD3x2, DC->i8MVD3y2, DC->i8MVD4x2, DC->i8MVD4y2));
	}
#endif

	iNumberOfMBsPerGOB = DC->iNumberOfMBsPerGOB;
	iMBNum             = fpBlockAction->uBlkNumber / 6;
	iMBOffset          = iMBNum % iNumberOfMBsPerGOB;
	iAbove			 = -6 * iNumberOfMBsPerGOB;
	bNoAbove           = (DC->bGOBHeaderPresent) || (iMBNum < iNumberOfMBsPerGOB);
	bNoRight			 = iMBOffset == (iNumberOfMBsPerGOB - 1);
	bUMV 				 = DC->bUnrestrictedMotionVectors;

	if (DC->uMBType != 2) 
	{    // One motion vector per macroblock
		// when either a GOB header is present or
		// we are on the first GOB, only look to the left
		if ( bNoAbove ) 
		{
			// only one predictor
			if (iMBOffset == 0)							// when on the left edge,
				mvx2 = mvy2 = 0;							// use 0, else
			else 
			{
				mvx2 = fpBlockAction[-6 + 1].i8MVx2;		// use upper right corner
				mvy2 = fpBlockAction[-6 + 1].i8MVy2;		// of MB to the left
			}
		}

		// no GOB header and not the first GOB
		// need all three predictors
		else 
		{ 
			// left predictor
			if (iMBOffset == 0)							// when on the left edge, 
				mvx1 = mvy1 = 0;							// use 0, else
			else 
			{ 
				mvx1 = fpBlockAction[-6 + 1].i8MVx2;		// use upper right corner
				mvy1 = fpBlockAction[-6 + 1].i8MVy2;		// of MB to the left
			}

			// above predictor
			// use lower left corner 
			// of MB directly above
			mvx2 = fpBlockAction[iAbove + 2].i8MVx2;
			mvy2 = fpBlockAction[iAbove + 2].i8MVy2;

			// upper right predictor
			if ( bNoRight )	// when on the right edge
				mvx3 = mvy3 = 0;							// use 0
			else
			{	// else use lower left corner
				// of MB above & to the right
				mvx3 = fpBlockAction[iAbove + 8].i8MVx2;
				mvy3 = fpBlockAction[iAbove + 8].i8MVy2;
			}

			// select the medium value and place it in mvx2 & mvy2
			MEDIAN(mvx1, mvx2, mvx3, scratch);
			MEDIAN(mvy1, mvy2, mvy3, scratch);

		}  // end if (header or 1st GOB) ... else ...

		//  mvx2 and mvy2 have the medium predictors compute the motion vector 
		//  by adding in the difference
		mvx = DC->i8MVDx2 + mvx2;
		mvy = DC->i8MVDy2 + mvy2; 

		//  check for Unrestricted Motion Vector mode and adjust the motion 
		//  vector if necessary using the appropriate strategy, finishing
		//  the decoding process.
		if (bUMV) 
		{
			if (mvx2 > 32) 
			{
				if (mvx > 63) mvx -=64;
			}  
			else if (mvx2 < -31) 
			{
				if (mvx < -63) mvx +=64;
			}  

			if (mvy2 > 32) 
			{
				if (mvy > 63) mvy -=64;
			}  
			else if (mvy2 < -31) 
			{
				if (mvy < -63) mvy +=64;
			}
		}
		else 
		{  // UMV off
			if (mvx > 31)	  mvx -= 64;
			else if (mvx < -32)  mvx += 64;
			if (mvy > 31)  mvy -= 64;
			else if (mvy < -32) mvy += 64;
		}

		// save into the block action stream,
		// duplicating for the other 3 Y blocks.
		fpBlockAction[0].i8MVx2 = 
		fpBlockAction[1].i8MVx2 = 
		fpBlockAction[2].i8MVx2 = 
		fpBlockAction[3].i8MVx2 = (I8)mvx;

		fpBlockAction[0].i8MVy2 =
		fpBlockAction[1].i8MVy2 = 
		fpBlockAction[2].i8MVy2 = 
		fpBlockAction[3].i8MVy2 = (I8)mvy;


		// Chroma motion vectors
		// divide by 2 and round according to spec
		fpBlockAction[4].i8MVx2 = 
		fpBlockAction[5].i8MVx2 = 
		(mvx >> 1) + QuarterPelRound[mvx & 0x03];
		fpBlockAction[4].i8MVy2 = 
		fpBlockAction[5].i8MVy2 =
		(mvy >> 1) + QuarterPelRound[mvy & 0x03];

	} // end one motion vector per macroblock
	else 
	{
		// fpBlockAction[iNext[i][j]] points to block #i's (j+1)th predictor
		int iNext[4][3] = {-5,2,8, 0,3,8, -3,0,1, 2,0,1};

		// adjust iNext pointers which need to point to the GOB above
		iNext[0][1] += iAbove;		// block 0, mv2 -- block 2 of above MB
		iNext[0][2] += iAbove;		// block 0, mv3	-- block 2 of above-right MB
		iNext[1][1] += iAbove;		// block 1, mv2 -- block 3 of above MB
		iNext[1][2] += iAbove;		// block 1, mv3	-- block 2 of above-right MB

		// fetch motion vector differences
		mvxd[0] = DC->i8MVDx2;
		mvyd[0] = DC->i8MVDy2;
		mvxd[1] = DC->i8MVD2x2;
		mvyd[1] = DC->i8MVD2y2;
		mvxd[2] = DC->i8MVD3x2;
		mvyd[2] = DC->i8MVD3y2;
		mvxd[3] = DC->i8MVD4x2;
		mvyd[3] = DC->i8MVD4y2;

		// loop on Lumina blocks in this MB
		for (i=0, mvx=0, mvy=0; i<4; i++) 
		{
			// get predictor 1
			if ( (i&1) || (iMBOffset) ) 
			{ // not on left edge
				mvxp[0] = fpBlockAction[iNext[i][0]].i8MVx2; 
				mvyp[0] = fpBlockAction[iNext[i][0]].i8MVy2;
			}
			else 
			{ // on left edge, zero the predictor
				mvxp[0] = mvyp[0] = 0;
			}

			// for predictors 2 and 3, check if we can 
			// look above and that we are on blocks 0 or 1
			if ( (bNoAbove) && (i < 2) ) 
			{
				// set predictor 2 equal to predictor 1
				mvxp[1] = mvxp[0]; 
				mvyp[1] = mvyp[0];

				if (bNoRight) 
				{
					// if on the right edge, zero predictor 3
					mvxp[2] = mvyp[2] = 0;
				}
				else 
				{ // else set predictor 3 equal to predictor 1
					mvxp[2] = mvxp[0]; 
					mvyp[2] = mvyp[0];
				} // end predictor 3

			}
			else 
			{ // okay to look up
				// get predictor 2
				mvxp[1] = fpBlockAction[iNext[i][1]].i8MVx2;
				mvyp[1] = fpBlockAction[iNext[i][1]].i8MVy2;

				// get predictor 3
                if ( (bNoRight) && (i < 2) ) { 
					// if on the right edge, zero predictor 3
					mvxp[2] = mvyp[2] = 0;
				}
				else 
				{ // else fetch it from the block action stream
					mvxp[2] = fpBlockAction[iNext[i][2]].i8MVx2;
					mvyp[2] = fpBlockAction[iNext[i][2]].i8MVy2;
				} // end predictor 3

			} // end predictors 2 & 3

			// got all of the candidate predictors now get the median
			// output in mv-p[1]
			MEDIAN( mvxp[0], mvxp[1], mvxp[2], scratch);
			MEDIAN( mvyp[0], mvyp[1], mvyp[2], scratch);

			// add in the difference,
			// put the freshly constructed motion vector in mv-p[0]
			// leaving the predictors in mv-p[1] for use if UMV is on.
			mvxp[0] = mvxp[1] + mvxd[i];
			mvyp[0] = mvyp[1] + mvyd[i]; 

			// check for Unrestricted Motion Vector mode
			// and, if necessary, adjust the motion vector according
			// to the appropriate decoding strategy, thereby
			// finishing the decoding process.
			if ( bUMV ) 
			{
				if (mvxp[1] > 32) 
				{
					if (mvxp[0] > 63) mvxp[0] -=64;
				}  
				else if (mvxp[1] < -31) 
				{
					if (mvxp[0] < -63) mvxp[0] +=64;
				}  

				if (mvyp[1] > 32) 
				{
					if (mvyp[0] > 63) mvyp[0] -=64;
				}  
				else if (mvyp[1] < -31) 
				{
					if (mvyp[0] < -63) mvyp[0] +=64;
				}
			}
			else 
			{  // UMV off
				if (mvxp[0] > 31)	  mvxp[0] -= 64;
				else if (mvxp[0] < -32)  mvxp[0] += 64;

				if (mvyp[0] > 31)  mvyp[0] -= 64;
				else if (mvyp[0] < -32) mvyp[0] += 64;
			}

			// finally store the result in the block action stream and
			// accumulate the sum of Lumina for the Chroma 
			mvx += (fpBlockAction[i].i8MVx2 = (I8)mvxp[0]);
			mvy += (fpBlockAction[i].i8MVy2 = (I8)mvyp[0]);

		} // end Lumina vectors

		// Compute the Chroma vectors
		// divide sum of Lumina by 8 and round according to spec
		fpBlockAction[4].i8MVx2 = 
		fpBlockAction[5].i8MVx2 = 
		(mvx >> 3) + SixteenthPelRound[mvx & 0x0f];
		fpBlockAction[4].i8MVy2 = 
		fpBlockAction[5].i8MVy2 = 
		(mvy >> 3) + SixteenthPelRound[mvy & 0x0f];

	} // end 4 motion vectors per macroblock


	DEBUGMSG(ZONE_DECODE_COMPUTE_MOTION_VECTORS, ("   %s: Motion vector = (%d, %d)\r\n", _fx_, fpBlockAction->i8MVx2, fpBlockAction->i8MVy2));

#ifdef _DEBUG
	if (DC->uMBType == 2)
	{
		for (int iVector = 1; iVector < 6; iVector++)
		{
			DEBUGMSG(
			    ZONE_DECODE_COMPUTE_MOTION_VECTORS, 
			    ("   %s: Motion vector %d = (%d, %d)\r\n", 
			        _fx_, iVector, fpBlockAction[iVector].i8MVx2, fpBlockAction[iVector].i8MVy2));
		}
	}
#endif

	return ICERR_OK;
}
#pragma code_seg()