/* *************************************************************************
**    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-1996 Intel Corporation.
**    All Rights Reserved.
**
** *************************************************************************
*/
/******************************************************************************
 * e1mbenc.cpp
 *
 * DESCRIPTION:
 *		Specific encoder compression functions.
 *
 * Routines:					Prototypes in:
 *  GOB_Q_RLE_VLC_WriteBS
 *  MB_Quantize_RLE
 *  ComputeCheckSum
 *  WriteMBCheckSum
 */
/* $Header:   S:\h26x\src\enc\e1mbenc.cpv   1.47   30 Oct 1996 09:58:46   MBODART  $
 *  $Log:   S:\h26x\src\enc\e1mbenc.cpv  $
// 
//    Rev 1.47   30 Oct 1996 09:58:46   MBODART
// Fixed assertion failure.  Need to reclamp unMQuant after adding delta.
// 
//    Rev 1.46   29 Oct 1996 11:18:18   RHAZRA
// Bug fix: in the IA code we previously modified MQuant on a MB basis
// even if we were operating with a fixed quantizer. Now we don't
// 
//    Rev 1.45   21 Oct 1996 09:05:16   RHAZRA
// 
// MMX integration
// 
//    Rev 1.44   21 Aug 1996 19:06:02   RHAZRA
// Added RTP generatio code; fixed additional divide-by-zero possibilities.
// 
//    Rev 1.42   21 Jun 1996 10:08:34   AKASAI
// Changes to e1enc.cpp, e1mbenc.cpp, ex5me.asm to support "improved
// bit rate control", changing MacroBlock Quantization within a
// row of MB's in addition to changing the Quantization change
// between rows of macro blocks.
// 
// ex5me.asm had a problem with SLF SWD.  Brian updated asm code.
// 
// 
//    Rev 1.41   14 May 1996 11:41:18   AKASAI
// Needed to test 0th and 1st coefficient to avoid clamping errors.
// 
//    Rev 1.40   14 May 1996 10:39:04   AKASAI
// Two files changed to hopefully eliminate Quantization clamping 
// artifacts and to reduce the max buffer overflow case: e1enc.cpp
// and e1mbenc.cpp.
// 
// In e1mbenc.cpp when the MQuant level is < 6 I test to see if
// the 0th coefficient is larger than the values representable
// at that Quant level if it is I increase the Quant level until
// the clamping artifact will not occur.  Note: I am test only 
// the Oth coefficient, there is the possibility that some other
// coefficient is larger but the performance trade off seems to
// indicate this is good for now and if we still see clamping
// artifacts we can add more testing later.
// 
// In e1enc.cpp I modified when the Overflow types of warnings are
// turn on as well as changing the rate the Quantization level
// changes at.
// 
//    Rev 1.39   24 Apr 1996 12:18:22   AKASAI
// Added re-compression strategy to encoder.  Had to change e1enc.cpp,
// e1enc.h and e1mbenc.cpp.  
// Basic strategy is if spending too many bits in a GOB quantize the
// next GOB at a higher rate.  If after compressing the frame too
// many bits have been used, re-compress the last GOB at a higher
// QUANT level if that still doesn't work send a "Skip" GOB.
// Needed to add extra parameter to GOB+Q_RLE_VLC_WriteBS because
// CalcMBQuant kept decreasing the QUANT when we were in trouble with
// possibly overflowing the buffer.
// 
//    Rev 1.38   22 Apr 1996 11:02:14   AKASAI
// Two files changed e1enc.cpp and e1mbenc.cpp to try and support
// allowing the Quantization values to go down to 2 instead of
// CLAMP to 6.
// This is part 1 of implementing the re-compression (what to do
// if exceed max compressed buffer size 8KBytes QCIF, 32KBytes FCIF).
// Also changed in e1enc was to limit request uFrameSize to 8KB or
// 32KB.  Problem was if user specified too large of a datarate
// request frame size would be larger than the allowed buffer size.
// If you try to compress qnoise10.avi or fnoise5.avi you get an
// ASSERT error until rest of re-compression is implemented.
// 
//    Rev 1.37   19 Apr 1996 14:26:28   SCDAY
// Added adaptive bit usage profile (Karl's BRC changes)
// 
//    Rev 1.36   08 Jan 1996 10:11:16   DBRUCKS
// add an assert
// 
//    Rev 1.35   29 Dec 1995 18:11:42   DBRUCKS
// 
// optimize walking pCurrMB and add CLAMP_N_TO(qp,6,31)
// 
//    Rev 1.34   27 Dec 1995 16:48:06   DBRUCKS
// moved incrementing InterCodeCnt from e1enc.cpp
// 
//    Rev 1.33   26 Dec 1995 17:45:18   DBRUCKS
// moved statistics to e1stat
// 
//    Rev 1.32   20 Dec 1995 14:56:52   DBRUCKS
// add timing stats
// 
//    Rev 1.31   18 Dec 1995 15:38:04   DBRUCKS
// improve stats
// 
//    Rev 1.30   15 Dec 1995 10:53:34   AKASAI
// Fixed bug that encoded the wrong type when spatial loop filter on
// bug 0 MV.  Was incorrectly been encoded with no spatial loop filter.
// This seemed to have caused the "#" bug.
// 
//    Rev 1.29   13 Dec 1995 13:59:08   DBRUCKS
// added include exutil.h
// parameter change in call to cnvt_fdct_output - uses INTRA boolean instead
// of blocktype
// 
//    Rev 1.28   07 Dec 1995 12:50:54   DBRUCKS
// integrate Macroblock checksum fixes
// 
//    Rev 1.27   04 Dec 1995 12:12:30   DBRUCKS
// Unsigned compares using MQuant and lastencoded -2 yielded 
// unexpected results when lastencoded was 1.
// 
//    Rev 1.26   01 Dec 1995 15:33:14   DBRUCKS
// 
// Added the bit rate controller support.  The one possibly confusing
// part is that the quantizer can change in the encoder on a macro block
// that is skipped or on one that does not have coefficients.  In either
// case the decoder is not told of the change.  The decoder is told of
// the change on the next macroblock that has coefficients.
// 
//    Rev 1.25   27 Nov 1995 17:53:40   DBRUCKS
// add spatial loop filtering
// 
//    Rev 1.24   22 Nov 1995 17:37:34   DBRUCKS
// cleanup me changes
// 
//    Rev 1.23   22 Nov 1995 15:34:52   DBRUCKS
// 
// Motion Estimation works - but needs to be cleaned up
// 
//    Rev 1.22   17 Nov 1995 14:26:20   BECHOLS
// 
// Made modifications so that this file can be made for ring 0.
// 
//    Rev 1.21   15 Nov 1995 14:40:34   AKASAI
// Union thing change ...
// (Integration point)
// 
//    Rev 1.20   01 Nov 1995 09:00:16   DBRUCKS
// cleanup
// 
//    Rev 1.19   27 Oct 1995 17:21:12   DBRUCKS
// fix MTYPE calc, improve var names and debug
// 
//    Rev 1.18   27 Oct 1995 15:06:30   DBRUCKS
// update cnvt_fdct_output
// 
//    Rev 1.17   27 Oct 1995 14:30:36   DBRUCKS
// delta frame support "coded", key frames tested
// 
//    Rev 1.15   17 Oct 1995 15:56:56   DBRUCKS
// cleanup debug message
// 
//    Rev 1.14   17 Oct 1995 15:52:10   DBRUCKS
// 
// turn off a debug message
// 
//    Rev 1.13   16 Oct 1995 11:41:44   DBRUCKS
// fix the sign part of the checksum
// 
//    Rev 1.12   29 Sep 1995 10:31:02   DBRUCKS
// change to use e35qrle to get the latest
// 
//    Rev 1.11   27 Sep 1995 16:53:48   DBRUCKS
// move MB checksum before MB
// 
//    Rev 1.10   26 Sep 1995 13:33:14   DBRUCKS
// fixed TCOEFF table 4,1 and on used earlier values
// 
//    Rev 1.9   26 Sep 1995 09:29:46   DBRUCKS
// turn on MBEncodeVLC
// 
//    Rev 1.8   26 Sep 1995 09:09:24   DBRUCKS
// add checksum test code
// 
//    Rev 1.7   25 Sep 1995 10:23:16   DBRUCKS
// 
// add checksum info AND
// fix the final param that is passed to MBEncodeVLC
// 
//    Rev 1.6   21 Sep 1995 20:37:56   BECHOLS
// Modified the VLC tables for H261.  I included a placeholder for the
// sign bit, so that I can achieve an optimization in the code.
// 
//    Rev 1.5   21 Sep 1995 18:14:48   BECHOLS
// Changed the initialization of the VLC tables for efficient use of memory,
// and proper operation with VLC code.  This is an intermediate step towards
// completion, but is not operable yet.
// 
//    Rev 1.4   20 Sep 1995 17:50:18   BECHOLS
// 
// Removed VLC_TCOEF_LAST_TBL and changed the initialization code that
// use to assume 2 DWORDS to now make use of a single DWORD to conserve
// memory.
// 
//    Rev 1.3   20 Sep 1995 16:34:28   BECHOLS
// Moved the data declared in E1VLC.H to this module, where it is used.
// 
//    Rev 1.2   20 Sep 1995 12:39:38   DBRUCKS
// turn on complete mb processing and 
// cleanup two routines
// 
//    Rev 1.1   18 Sep 1995 10:09:54   DBRUCKS
// 
// activate more of the mb processing
// 
//    Rev 1.0   12 Sep 1995 18:57:16   BECHOLS
// Initial revision.
 */

#include "precomp.h"

#ifdef CHECKSUM_MACRO_BLOCK
static U32 ComputeCheckSum(I8 * pi8MBRunValTriplets, I8 * pi8EndAddress, I32 iBlockNumber);
static void WriteMBCheckSum(U32 uCheckSum, U8 * pu8PictureStart, U8 ** ppu8BitStream, U8 * pu8BitOffset, UN unCurrentMB);
#endif
static I8 * MB_Quantize_RLE(I32 **DCTCoefs, I8 *MBRunValPairs, U8 * CodedBlocks, U8 BlockType, I32 QP, U32 *puChecksum);

extern char string[128];

/*
 * VLC table for TCOEFs
 * Table entries are size INCLUDING PLACE HOLDER FOR SIGN BIT, code.
 * Stored as (size, value)
 */
int VLC_TCOEF[102*2] = {
	0X0003, 0x0006,	// 0
	0X0005, 0x0008,
	0X0006, 0x000A,
	0X0008, 0x000C,
	0X0009, 0x004C,
	0X0009, 0x0042,
	0X000B, 0x0014,
	0X000D, 0x003A,
	0X000D, 0x0030,
	0X000D, 0x0026,
	0X000D, 0x0020,
	0X000E, 0x0034,
	0X000E, 0x0032,
	0X000E, 0x0030,
	0X000E, 0x002E,
	0X0004, 0x0006,	// 1
	0X0007, 0x000C,
	0X0009, 0x004A,
	0X000B, 0x0018,
	0X000D, 0x0036,
	0X000E, 0x002C,
	0X000E, 0x002A,
	0X0005, 0x000A,	// 2
	0X0008, 0x0008,
	0X000B, 0x0016,
	0X000D, 0x0028,
	0X000E, 0x0028,
	0X0006, 0x000E,	// 3
	0X0009, 0x0048,
	0X000D, 0x0038,
	0X000E, 0x0026,
	0X0006, 0x000C,	// 4
	0X000B, 0x001E,
	0X000D, 0x0024,
	0X0007, 0x000E,	// 5
	0X000B, 0x0012,
	0X000E, 0x0024,
	0X0007, 0x000A,	// 6
	0X000D, 0x003C,
	0X0007, 0x0008,	// 7
	0X000D, 0x002A,
	0X0008, 0x000E, // 8
	0X000D, 0x0022,
	0X0008, 0x000A,	// 9
	0X000E, 0x0022,
	0X0009, 0x004E,	// 10
	0X000E, 0x0020,
	0X0009, 0x0046,	// 11
	0X0009, 0x0044,	// 12
	0X0009, 0x0040,	// 13
	0X000B, 0x001C,	// 14
	0X000B, 0x001A,	// 15
	0X000B, 0x0010,	// 16
	0X000D, 0x003E,	// 17
	0X000D, 0x0034,	// 18
	0X000D, 0x0032,	// 19
	0X000D, 0x002E,	// 20
	0X000D, 0x002C,	// 21
	0X000E, 0x003E,	// 22
	0X000E, 0x003C,	// 23
	0X000E, 0x003A,	// 24
	0X000E, 0x0038,	// 25
 	0X000E, 0x0036	// 26
  };

/*
 * This table lists the maximum level represented in the
 * VLC table for a given run. If the level exceeds the
 * max, then escape codes must be used to encode the
 * run & level.
 * The table entries are of the form {maxlevel, ptr to table for this run}.
 */

T_MAXLEVEL_PTABLE TCOEF_RUN_MAXLEVEL[65] = {
	{15, &VLC_TCOEF[0]},	// run of 0
	{ 7, &VLC_TCOEF[15*2]},	// run of 1
	{ 5, &VLC_TCOEF[22*2]},	// run of 2
	{ 4, &VLC_TCOEF[27*2]},	// run of 3
	{ 3, &VLC_TCOEF[31*2]},	// run of 4
	{ 3, &VLC_TCOEF[34*2]},	// run of 5
	{ 2, &VLC_TCOEF[37*2]},	// run of 6
	{ 2, &VLC_TCOEF[39*2]},	// run of 7
	{ 2, &VLC_TCOEF[41*2]},	// run of 8
	{ 2, &VLC_TCOEF[43*2]},	// run of 9
	{ 2, &VLC_TCOEF[45*2]},	// run of 10
	{ 1, &VLC_TCOEF[47*2]},	// run of 11
	{ 1, &VLC_TCOEF[48*2]},	// run of 12
	{ 1, &VLC_TCOEF[49*2]},	// run of 13
	{ 1, &VLC_TCOEF[50*2]},	// run of 14
	{ 1, &VLC_TCOEF[51*2]},	// run of 15
	{ 1, &VLC_TCOEF[52*2]},	// run of 16
	{ 1, &VLC_TCOEF[53*2]},	// run of 17
	{ 1, &VLC_TCOEF[54*2]},	// run of 18
	{ 1, &VLC_TCOEF[55*2]},	// run of 19
	{ 1, &VLC_TCOEF[56*2]},	// run of 20
	{ 1, &VLC_TCOEF[57*2]},	// run of 21
	{ 1, &VLC_TCOEF[58*2]},	// run of 22
	{ 1, &VLC_TCOEF[59*2]},	// run of 23
	{ 1, &VLC_TCOEF[60*2]},	// run of 24
	{ 1, &VLC_TCOEF[61*2]},	// run of 25
	{ 1, &VLC_TCOEF[62*2]},	// run of 26
	{ 0, 0},	// run of 27 not in VLC table
	{ 0, 0},	// run of 28 not in VLC table
	{ 0, 0},	// run of 29 not in VLC table
	{ 0, 0},	// run of 30 not in VLC table
	{ 0, 0},	// run of 31 not in VLC table
	{ 0, 0},	// run of 32 not in VLC table
	{ 0, 0},	// run of 33 not in VLC table
	{ 0, 0},	// run of 34 not in VLC table
	{ 0, 0},	// run of 35 not in VLC table
	{ 0, 0},	// run of 36 not in VLC table
	{ 0, 0},	// run of 37 not in VLC table
	{ 0, 0},	// run of 38 not in VLC table
	{ 0, 0},	// run of 39 not in VLC table
	{ 0, 0},	// run of 40 not in VLC table
	{ 0, 0},	// run of 41 not in VLC table
	{ 0, 0},	// run of 42 not in VLC table
	{ 0, 0},	// run of 43 not in VLC table
	{ 0, 0},	// run of 44 not in VLC table
	{ 0, 0},	// run of 45 not in VLC table
	{ 0, 0},	// run of 46 not in VLC table
	{ 0, 0},	// run of 47 not in VLC table
	{ 0, 0},	// run of 48 not in VLC table
	{ 0, 0},	// run of 49 not in VLC table
	{ 0, 0},	// run of 50 not in VLC table
	{ 0, 0},	// run of 51 not in VLC table
	{ 0, 0},	// run of 52 not in VLC table
	{ 0, 0},	// run of 53 not in VLC table
	{ 0, 0},	// run of 54 not in VLC table
	{ 0, 0},	// run of 55 not in VLC table
	{ 0, 0},	// run of 56 not in VLC table
	{ 0, 0},	// run of 57 not in VLC table
	{ 0, 0},	// run of 58 not in VLC table
	{ 0, 0},	// run of 59 not in VLC table
	{ 0, 0},	// run of 60 not in VLC table
	{ 0, 0},	// run of 61 not in VLC table
	{ 0, 0},	// run of 62 not in VLC table
	{ 0, 0},	// run of 63 not in VLC table
	{ 0, 0}		// run of 64 not in VLC table
	 };

/* VLC table for MBA
 * Table is stored as {number of bits, code}.
 * The index to the table should be the MBA value.
 * The zero entry is not used.
 */
int VLC_MBA[34][2] =
	{ {0, 0},     /* Not Used */
	  {1, 0x1},   /* 1 */
	  {3, 0x3},   /* 2 */
	  {3, 0x2},   /* 3 */
	  {4, 0x3},   /* 4 */
	  {4, 0x2},   /* 5 */
	  {5, 0x3},   /* 6 */
	  {5, 0x2},   /* 7 */
	  {7, 0x7},   /* 8 */
	  {7, 0x6},   /* 9 */
	  {8, 0xB},   /* 10 */
	  {8, 0xA},   /* 11 */
	  {8, 0x9},	  /* 12 */
	  {8, 0x8},   /* 13 */
	  {8, 0x7},	  /* 14 */
	  {8, 0x6},	  /* 15 */
	  {10, 0x17}, /* 16 */
	  {10, 0x16}, /* 17 */
	  {10, 0x15}, /* 18 */
	  {10, 0x14}, /* 19 */
	  {10, 0x13}, /* 20 */
	  {10, 0x12}, /* 21 */
	  {11, 0x23}, /* 22 */
	  {11, 0x22}, /* 23 */
	  {11, 0x21}, /* 24 */
	  {11, 0x20}, /* 25 */
	  {11, 0x1F}, /* 26 */
	  {11, 0x1E}, /* 27 */
	  {11, 0x1D}, /* 28 */
	  {11, 0x1C}, /* 29 */
	  {11, 0x1B}, /* 30 */
	  {11, 0x1A}, /* 31 */
	  {11, 0x19}, /* 32 */
	  {11, 0x18}  /* 33 */
	};

/* VLC table for MTYPE
 * Table is stored as {number of bits, code}.
 */
int VLC_MTYPE[10][2] =
	{ {4, 0x1}, /* Intra        :                TCOEFF */
	  {7, 0x1}, /* Intra        : MQUANT         TCOEEF */
	  {1, 0x1}, /* Inter        :            CBP TCOEFF */
	  {5, 0x1}, /* Inter        : MQUANT     CBP TCOEFF */
	  {9, 0x1}, /* Inter MC     :        MVD            */
	  {8, 0x1}, /* Inter MC     :        MVD CBP TCOEFF */
	  {10,0x1}, /* Inter MC     : MQUANT MVD CBP TCOEFF */
	  {3, 0x1}, /* Inter MC FIL :        MVD            */
	  {2, 0x1}, /* Inter MC FIL :        MVD CBP TCOEFF */
	  {6, 0x1}  /* Inter MC FIL : MQUANT MVD CBP TCOEFF */
    };

/* VLC table for CBP
 * Table is stored as {number of bits, code}.
 */
int VLC_CBP[64][2] =
	{ {0, 0},   /* Not Used - if zero it is not coded */
	  {5, 0x0B},/*  1 */
	  {5, 0x09},/*  2 */
	  {6, 0x0D},/*  3 */
	  {4, 0xD}, /*  4 */
	  {7, 0x17},/*  5 */
	  {7, 0x13},/*  6 */
	  {8, 0x1F},/*  7 */
	  {4, 0xC}, /*  8 */
	  {7, 0x16},/*  9 */

	  {7, 0x12},/* 10 */
	  {8, 0x1E},/* 11 */
	  {5, 0x13},/* 12 */
	  {8, 0x1B},/* 13 */
	  {8, 0x17},/* 14 */
	  {8, 0x13},/* 15 */
	  {4, 0xB}, /* 16 */
	  {7, 0x15},/* 17 */
	  {7, 0x11},/* 18 */
	  {8, 0x1D},/* 19 */

	  {5, 0x11},/* 20 */
	  {8, 0x19},/* 21 */
	  {8, 0x15},/* 22 */
	  {8, 0x11},/* 23 */
	  {6, 0x0F},/* 24 */
	  {8, 0x0F},/* 25 */
	  {8, 0x0D},/* 26 */
	  {9, 0x03},/* 27 */
	  {5, 0x0F},/* 28 */
	  {8, 0x0B},/* 29 */

	  {8, 0x07},/* 30 */
	  {9, 0x07},/* 31 */
	  {4, 0xA}, /* 32 */
	  {7, 0x14},/* 33 */
	  {7, 0x10},/* 34 */
	  {8, 0x1C},/* 35 */
	  {6, 0x0E},/* 36 */
	  {8, 0x0E},/* 37 */
	  {8, 0x0C},/* 38 */
	  {9, 0x02},/* 39 */

	  {5, 0x10},/* 40 */
	  {8, 0x18},/* 41 */
	  {8, 0x14},/* 42 */
	  {8, 0x10},/* 43 */
	  {5, 0x0E},/* 44 */
	  {8, 0x0A},/* 45 */
	  {8, 0x06},/* 46 */
	  {9, 0x06},/* 47 */
	  {5, 0x12},/* 48 */
	  {8, 0x1A},/* 49 */

	  {8, 0x16},/* 50 */
	  {8, 0x12},/* 51 */
	  {5, 0x0D},/* 52 */
	  {8, 0x09},/* 53 */
	  {8, 0x05},/* 54 */
	  {9, 0x05},/* 55 */
	  {5, 0x0C},/* 56 */
	  {8, 0x08},/* 57 */
	  {8, 0x04},/* 58 */
	  {9, 0x04},/* 59 */

	  {3, 0x7}, /* 60 */
	  {5, 0x0A},/* 61 */
	  {5, 0x08},/* 62 */
	  {6, 0x0C},/* 63 */
    };

/* VLC table for MVD
 * Table is stored as {number of bits, code}.
 */
int VLC_MVD[32][2] =
	{ {11, 0x19}, /* -16 & 16 */
	  {11, 0x1B}, /* -15 & 17 */
	  {11, 0x1D}, /* -14 & 18 */
	  {11, 0x1F}, /* -13 & 19 */
	  {11, 0x21}, /* -12 & 20 */
	  {11, 0x23}, /* -11 & 21 */
	  {10, 0x13}, /* -10 & 22 */
	  {10, 0x15}, /*  -9 & 23 */
	  {10, 0x17}, /*  -8 & 24 */
	  { 8, 0x07}, /*  -7 & 25 */
	  { 8, 0x09}, /*  -6 & 26 */
	  { 8, 0x0B}, /*  -5 & 27 */
	  { 7, 0x07}, /*  -4 & 28 */
	  { 5, 0x03}, /*  -3 & 29 */
	  { 4,  0x3}, /*  -2 & 30 */
	  { 3,  0x3}, /*  -1 */
	  { 1,  0x1}, /*   0 */
	  { 3,  0x2}, /*   1 */
	  { 4,  0x2}, /*   2 & -30 */
	  { 5, 0x02}, /*   3 & -29 */
	  { 7, 0x06}, /*   4 & -28 */
	  { 8, 0x0A}, /*   5 & -27 */
	  { 8, 0x08}, /*   6 & -26 */
	  { 8, 0x06}, /*   7 & -25 */
	  {10, 0x16}, /*   8 & -24 */
	  {10, 0x14}, /*   9 & -23 */
	  {10, 0x12}, /*  10 & -22 */
	  {11, 0x22}, /*  11 & -21 */
	  {11, 0x20}, /*  12 & -20 */
	  {11, 0x1E}, /*  13 & -19 */
	  {11, 0x1C}, /*  14 & -18 */
	  {11, 0x1A}  /*  15 & -17 */
	};

/* Table to limit quant changes through out a row of Macro Blocks */
static U8 QPMaxTbl[32] = 
	{ 0,		/* Not Used */
	  1,		/* Not Used when clamp to (2,31) */
	  1,		/* 2 */
	  1,		/* 3 */
	  2,		/* 4 */
	  2,		/* 5 */
	  2,		/* 6 */
	  2,		/* 7 */
	  2,		/* 8 */
	  2,		/* 9 */
	  2,		/* 10 */
	  2,		/* 11 */
	  2,		/* 12 */
	  2,		/* 13 */
	  2,		/* 14 */
	  2,		/* 15 */
	  2,		/* 16 */
	  2,		/* 17 */
	  2,		/* 18 */
	  2,		/* 19 */
	  2,		/* 20 */
	  2,		/* 21 */
	  2,		/* 22 */
	  2,		/* 23 */
	  2,		/* 24 */
	  2,		/* 25 */
	  2,		/* 26 */
	  2,		/* 27 */
	  2,		/* 28 */
	  2,		/* 29 */
	  2,		/* 30 */
	  2			/* 31 */
	};

/* Table to limit Quant changes between Rows of Marco Blocks */
extern U8 MaxChangeRowMBTbl[32]; 

/*****************************************************************************
 *
 *  GOB_Q_RLE_VLC_WriteBS
 *
 *  Quantize and RLE each macroblock, then VLC and write to stream
 */
void GOB_Q_RLE_VLC_WriteBS(
	T_H263EncoderCatalog * EC,
	I32 *piDCTCoefs,
	U8 **ppu8BitStream,
	U8 *pu8BitOffset,
	UN unStartingMB,
	UN unGQuant,
	BOOL bOverFlowWarningFlag,
    BOOL bRTPHeader, //RTP: switch
    U32  uGOBNumber,        // RTP: info
	U8 u8QPMin
	)
{
	T_MBlockActionStream *pCurrMB = NULL;
	T_MBlockActionStream *pLastMB = NULL;
	int iMBIndex;
	int iLastMBIndex = -1;
	UN unCurrentMB;
	U32 uCheckSum;
	UN unMBA;
	UN unLastEncodedMBA=0; // RTP: information
    UN unLastCodedMB = 0;    // RTP: information
    UN unCBP;
	UN unMQuant;
	UN unLastEncodedMQuant;
	UN unMType;
	UN bWriteTCOEFF;
	UN bWriteMVD;
	UN bWriteMQuant;
	I8 MBRunValSign[65*3*6], *pi8EndAddress, *rvs;
	T_MBlockActionStream *pMBActionStream = EC->pU8_MBlockActionStream;
	int bIntraBlock;
  	int	inPrecedingHMV;
  	int inPrecedingVMV;
  	int	inHDelta;
  	int inVDelta;
	U32 uCumFrmSize;
	U32 uBlockCount;
	ENC_BITSTREAM_INFO * pBSInfo = &EC->BSInfo;
	UN unMQuantLast;

	U32 SWDmax[3] = {0,0,0};
	U32 SWDmin[3] = {65536,65536,65536};
	U32 SWDrange[3] = {0,0,0};
	U32 SWDSum[3] = {0,0,0};
	U32 SWDNum[3] = {0,0,0};
	double SWDAvg[3] = {0.0,0.0,0.0};
	double Step, Delta;
	int QPMax;
	int NeedClamp=0;
	int irow;
	U8 SaveQuants[3];
	UN unSaveMQuant;


	unMQuant = unGQuant;
	unMQuantLast = unMQuant;	// save last MQuant so can reset if needed
	/* initially it should be the same because the GOB header
	 * included the GQuant.
	 */
	unLastEncodedMQuant = unMQuant;  

	unSaveMQuant = unGQuant;
	SaveQuants[0] = unSaveMQuant;

	/* New code to modify Quant inside a row of MB based on SWD */
	/* Loop through each macroblock of the GOB to find min and max SWD
	 */
	pCurrMB = &pMBActionStream[unStartingMB];
	for(irow = 0; irow < 3; irow++)
	{
		for(iMBIndex = irow*11 ; iMBIndex < (irow+1)*11; iMBIndex++, pLastMB = pCurrMB++)
		{
			if (pCurrMB->BlockType != INTRABLOCK)
			{
//				ASSERT(pCurrMB->SWD >= 0); Always True
				SWDSum[irow] += pCurrMB->SWD;
				SWDNum[irow]++;
				if (pCurrMB->SWD > SWDmax[irow])
					SWDmax[irow] = pCurrMB->SWD;
				if (pCurrMB->SWD < SWDmin[irow])
					SWDmin[irow] = pCurrMB->SWD;
			}
		}
	}
	SWDrange[0] = SWDmax[0] - SWDmin[0];
	SWDrange[1] = SWDmax[1] - SWDmin[1];
	SWDrange[2] = SWDmax[2] - SWDmin[2];

    if (SWDNum[0] != 0)
	    SWDAvg[0] = (double) SWDSum[0] / SWDNum[0];
    else
        SWDAvg[0] = 0.0;

    if (SWDNum[1] != 0)
	   SWDAvg[1] = (double) SWDSum[1] / SWDNum[1];
    else
       SWDAvg[1] = 0.0;

    if (SWDNum[2] != 0)
    	SWDAvg[2] = (double) SWDSum[2] / SWDNum[2];
    else
        SWDAvg[2] = 0.0;

	QPMax = unGQuant + QPMaxTbl[unGQuant];
	if (QPMax > 31)
		QPMax = 32;

    if ((SWDAvg[0] - SWDmin[0]) != 0) 
	    Step = (double) (QPMax - unGQuant)/(SWDAvg[0] - SWDmin[0]);
    else
        Step = 0.0;

	/* Loop through each macroblock of the GOB.
	 */
	pLastMB = NULL;
	pCurrMB = &pMBActionStream[unStartingMB];
	for(iMBIndex = 0 ; iMBIndex < 33; iMBIndex++, pLastMB = pCurrMB++)
	{

		unCurrentMB = unStartingMB + (unsigned int)iMBIndex;

		#ifdef DEBUG_ENC
		wsprintf(string, "MB #%d: QP=%d", unCurrentMB, unMQuant);
		trace(string);
		#endif


		if (bRTPHeader)
        {
            H261RTP_MBUpdateBsInfo(EC, 
				                   pCurrMB, 
								   unLastEncodedMQuant, 
								   (U32 )unLastEncodedMBA, 
								   uGOBNumber,
                                   *ppu8BitStream, 
								   (U32) *pu8BitOffset,
                                   unCurrentMB,
                                   unLastCodedMB
								   );
        }

		unMQuant = unMQuantLast;	// reset MQuant in case needed to
									// to raise on previous MB to avoid
									// Quant clamping artifact.

									/* Look to update the Quant on each new row.
		 */
        if (EC->bBitRateControl && ((iMBIndex == 11) || (iMBIndex == 22)))
        {
	        /* Calculate number of bytes used in frame so far.
			 */
	        uCumFrmSize = *ppu8BitStream - EC->pU8_BitStream;

            unMQuant = CalcMBQUANT(&(EC->BRCState), EC->uBitUsageProfile[unCurrentMB], EC->uBitUsageProfile[EC->NumMBs], uCumFrmSize, EC->PictureHeader.PicCodType);

			QPMax = unMQuant + QPMaxTbl[unMQuant];
			if (QPMax > 31)
				QPMax = 32;
            if ((SWDAvg[iMBIndex/11] - SWDmin[iMBIndex/11]) != 0) 
			    Step = (double) (QPMax - unMQuant)/(SWDAvg[iMBIndex/11] - SWDmin[iMBIndex/11]);
            else
                Step = 0.0;

	   		EC->uBitUsageProfile[unCurrentMB] = uCumFrmSize;

			if (bOverFlowWarningFlag)
			{
				DBOUT("DON'T CHANGE QUANT SET unMQuant = unGQuant");
				unMQuant = unGQuant;
			}
		    else if ((int)unMQuant > ((int)unLastEncodedMQuant + MaxChangeRowMBTbl[unGQuant]))
			{
				DBOUT("Slowing MQuant increase + [1-4]");
				unMQuant = unLastEncodedMQuant + MaxChangeRowMBTbl[unMQuant];
			}
			else if ((int)unMQuant < ((int)unLastEncodedMQuant -2))
			{
				DBOUT("Slowing MQuant decrease to -2");
				unMQuant = unLastEncodedMQuant -2;
			}

			//CLAMP_N_TO(unMQuant,6,31);
			if (EC->BRCState.uTargetFrmSize == 0)
			{
				CLAMP_N_TO(unMQuant,6,31);
			}
			else
			{
				CLAMP_N_TO(unMQuant, u8QPMin, 31);
			}
			#ifdef DEBUG_BRC
			wsprintf(string,"At MB %d MQuant=%d", unCurrentMB, unMQuant);
			DBOUT(string);
			#endif

			#ifdef DEBUG_RECOMPRESS
			wsprintf(string,"At MB %d MQuant=%d uCumFrmSize=%d", unCurrentMB, unMQuant,uCumFrmSize*8);
			DBOUT(string);
			//trace(string);
			#endif

	        //EC->uQP_cumulative += unMQuant;
			//EC->uQP_count++;

			unSaveMQuant = unMQuant;
			if (iMBIndex == 11)
				SaveQuants[1] = unSaveMQuant;
			else
				SaveQuants[2] = unSaveMQuant;
        }

		/* new MB Quant code */
		if (pCurrMB->BlockType != INTRABLOCK)
		{
           if (EC->BRCState.uTargetFrmSize != 0)
		   {
			if (pCurrMB->SWD >= SWDAvg[iMBIndex/11])
			{
				Delta = (double) -1.0 * ((double) (pCurrMB->SWD - SWDAvg[iMBIndex/11]) * Step);
				if (Delta < -2.0)
				{
					Delta = -2.0;
					NeedClamp++;
				}
			}
			else
			{
				Delta = (double) (SWDAvg[iMBIndex/11] - pCurrMB->SWD)*Step;
			}
		   }
		   else
		
			    Delta = 0.0;

			if (Delta > 0.0)
			{
				unMQuant = unSaveMQuant + (int) (Delta);
				/* Need to clamp again, but only worry about upper limit */
				if (unMQuant > 31)
				    unMQuant = 31;
			}
			else
			{
				unMQuant = unSaveMQuant + (int) (Delta - 0.5);
				/* Need to clamp again, but only worry about lower limit */
			    if (EC->BRCState.uTargetFrmSize == 0)
			    {
				    if (unMQuant < 6)
				        unMQuant = 6;
			    }
			    else
			    {
				    if (unMQuant < 2)
				        unMQuant = 2;
			    }
			}

		}
		/* end new stuff */

		/* Quantize and RLE each block in the macroblock, skipping empty blocks as denoted by pu8CodedBlocks.
		 * If any more blocks are empty after quantization then the appropriate pu8CodedBlocks bit is cleared.
		 */
		//ASSERT(unMQuant >= 6 && unMQuant <= 31); /* CLAMP_N_TO(var,6,31) */
		if (EC->BRCState.uTargetFrmSize == 0)
		{
			ASSERT(unMQuant >= 6 && unMQuant <= 31); /* CLAMP_N_TO(var,6,31) */
		}
		else
		{
			ASSERT(unMQuant >= 2 && unMQuant <= 31); /* CLAMP_N_TO(var,6,31) */
		}

		/* Check iDCTCoefs to see if need to raise quant level to avoid
		 * clamping artifacts.
		 */
		// first block is at piDCTCoefs
		// second block is at piDCTCoefs + 0x80 and so on
		// coefficients are unsigned shorts
		// first coefficient is at 6 bytes, 3 words
		// second coefficient is at 38 bytes, 19 words
		// third coefficient is at 4 bytes, 2 words
		// forth coefficient is at 36 bytes, 18 words

		unMQuantLast = unMQuant;

		if (unMQuant < 6)
		{
			I8 iBlockNum;
			U8 u8Bitmask = 1;
			I32 * ptmpiDCTCoefs = piDCTCoefs;
			int coef0, coef1;
			int biggestcoefval = -2048;
			int smallestcoefval = 2048;

			#ifdef DEBUG_QUANT
			wsprintf(string,"At MB %d MQuant=%d", unCurrentMB, unMQuant);
			DBOUT(string);
			//trace(string);
			#endif

			for(iBlockNum = 0; iBlockNum < 6; iBlockNum++, u8Bitmask <<= 1)
			{
				/* Skip this block if not coded.
				 */
				if( (pCurrMB->CodedBlocks & u8Bitmask) == 0)
				{
					continue;
				}
	    		if(IsIntraBlock(pCurrMB->BlockType))	// if Intra
				{
					coef0 = ((int)*((U16*)ptmpiDCTCoefs+3)) >> 4; 
				}
				else
				{
					coef0 = ((int)(*((U16*)ptmpiDCTCoefs+3) - 0x8000) ) >> 4;
				}

				coef1 = ((int)(*((U16*)ptmpiDCTCoefs+19) - 0x8000)) >> 4;

				#ifdef DEBUG_QUANT
				wsprintf(string,"At Block %d 0 = %x %d", iBlockNum,coef0,coef0);
				//DBOUT(string);
				//trace(string);
				#endif

				if (coef0 > biggestcoefval)
				{
					biggestcoefval = coef0;
				}
				if (coef1 > biggestcoefval)
				{
					biggestcoefval = coef1;
				}

				if (coef0 < smallestcoefval)
				{
					smallestcoefval = coef0;
				}
				if (coef1 < smallestcoefval)
				{
					smallestcoefval = coef1;
				}

				ptmpiDCTCoefs += 32;		
			}

			#ifdef DEBUG_QUANT
			wsprintf(string,"biggest = %x %d, smallest = %x %d",
			biggestcoefval, biggestcoefval, smallestcoefval, smallestcoefval);
				DBOUT(string);
			//	trace(string);
			#endif

			if (unMQuant == 5) {
				if ((biggestcoefval > 1275) || (smallestcoefval < -1275))
					unMQuant = 6;
			}
			else if (unMQuant == 4) {
				if ((biggestcoefval > 1275) || (smallestcoefval < -1275))
					unMQuant = 6;
				else if ((biggestcoefval > 1019) || (smallestcoefval < -1019))
					unMQuant = 5;
			}
			else if (unMQuant == 3) {
				if ((biggestcoefval > 1275) || (smallestcoefval < -1275))
					unMQuant = 6;
				else if ((biggestcoefval > 1019) || (smallestcoefval < -1019))
					unMQuant = 5;
				else if ((biggestcoefval > 765) || (smallestcoefval < -765))
					unMQuant = 4;
			}
			else {
				if ((biggestcoefval > 1275) || (smallestcoefval < -1275))
					unMQuant = 6;
				else if ((biggestcoefval > 1019) || (smallestcoefval < -1019))
					unMQuant = 5;
				else if ((biggestcoefval > 765) || (smallestcoefval < -765))
					unMQuant = 4;
				else if ((biggestcoefval > 509) || (smallestcoefval < -509))
					unMQuant = 3;
			}

			#ifdef DEBUG_QUANT
			wsprintf(string,"At MB %d MQuant=%d", unCurrentMB, unMQuant);
			DBOUT(string);
			//trace(string);
			#endif
		}

		/* This is the place to trace how Quant on a MB bases is varying
		*/
	    EC->uQP_cumulative += unMQuant;
		EC->uQP_count++;

	

	    pi8EndAddress = MB_Quantize_RLE(
	    		&piDCTCoefs,
	    		(I8 *) MBRunValSign,
	    		&(pCurrMB->CodedBlocks),
	    		pCurrMB->BlockType,
				unMQuant,
				&uCheckSum
	    	);

		

		pBSInfo->uQuantsUsedOnBlocks[unMQuant] += 6;

		bWriteMVD = (pCurrMB->BlkY1.PHMV != 0) ||
		  	        (pCurrMB->BlkY1.PVMV != 0) ||
	    			(IsSLFBlock(pCurrMB->BlockType)) ;


	    if (IsInterBlock(pCurrMB->BlockType)) 
		{
			/* Check if the Inter block is not coded?
			 */
			if ( ((pCurrMB->CodedBlocks & 0x3f) == 0) &&
		  	     (! bWriteMVD) )
		    {
				#ifdef DEBUG_MBLK
				wsprintf(string, "Inter MB (index=#%d) has neither Coeff nor MV - skipping", unCurrentMB);
				DBOUT(string);
				#endif
#ifdef FORCE_STUFFING
PutBits(FIELDVAL_MBA_STUFFING, FIELDLEN_MBA_STUFFING, ppu8CurBitStream, pu8BitOffset);
#endif
				continue;
			}
		}

		#ifdef CHECKSUM_MACRO_BLOCK
		/* Write a checksum before all coded blocks
		 */
		WriteMBCheckSum(uCheckSum, EC->pU8_BitStream,ppu8BitStream, pu8BitOffset, unCurrentMB);
		#endif

		/* Calculate the MB header information
		 */

		unMBA = iMBIndex - iLastMBIndex;
		iLastMBIndex = iMBIndex;
		unLastEncodedMBA = unMBA;
        unLastCodedMB = iMBIndex;
        
		
		/* Note: The calculation of whether to write MQuant is done after
		 * skipping macro blocks in order to handle the case that the 11th
		 * or 22nd macro blocks are skipped.  If they are skipped then
		 * the next macro block will be used to write the new quant value.
		 */

	    if(IsIntraBlock(pCurrMB->BlockType))
		{
	        ASSERT(pCurrMB->BlockType == INTRABLOCK);
			if (EC->PictureHeader.PicCodType != INTRAPIC)
			{	        
				pCurrMB->InterCodeCnt = ((U8)unCurrentMB)&0x7;
			} 

			bIntraBlock = 1;
			unCBP = 0;					   /* Never write CBP for Intra blocks */
			uBlockCount = 6;
			bWriteTCOEFF = 1;			   /* Always include TCOEFF for Intra blocks */
			
			/* Since we always have coefficients for Intra MBs we can always update
			 * the MQuant value.
			 */
			bWriteMQuant = (unMQuant != unLastEncodedMQuant);
			unLastEncodedMQuant = unMQuant;
			
			unMType = 0 + bWriteMQuant;	   /* Calculate MTYPE */
			bWriteMVD = 0;				   /* No motion vectors for INTRA */
		} 
		else
		{
			ASSERT(IsInterBlock(pCurrMB->BlockType));
                
			bIntraBlock = 0;

			unCBP  = (pCurrMB->CodedBlocks & 0x1) << 5;  /* x0 0000 */
			unCBP |= (pCurrMB->CodedBlocks & 0x2) << 3;	 /* 0x 0000 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x4) << 1;	 /* 00 x000 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x8) >> 1;	 /* 00 0x00 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x10) >> 3; /* 00 00x0 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x20) >> 5; /* 00 000x */

			uBlockCount = 0;
			if (unCBP &  0x1) uBlockCount++;
			if (unCBP &  0x2) uBlockCount++;
			if (unCBP &  0x4) uBlockCount++;
			if (unCBP &  0x8) uBlockCount++;
			if (unCBP & 0x10) uBlockCount++;
			if (unCBP & 0x20) uBlockCount++;

			/* Increment the count if it is transmitted 
			 * "should be forcibly updated at least once every
			 *  132 times it is transmitted" 3.4
			 */
			if (uBlockCount != 0 )
			{
        		pCurrMB->InterCodeCnt++;
			}
	
			bWriteTCOEFF = (unCBP != 0);
		
			if (bWriteTCOEFF)
			{
				/* We can only update the MQuant value when we have coefficients
				 */
				bWriteMQuant = (unMQuant != unLastEncodedMQuant);
				unLastEncodedMQuant = unMQuant;
			}
			else
			{
				bWriteMQuant = 0;
			}
			#ifdef CHECKSUM_MACRO_BLOCK
			/* Either there are coefficients or the checksum should equal zero
			 */
			ASSERT(bWriteTCOEFF || uCheckSum == 0);
			#endif	

			/* Calculate MType
			 */
		  	unMType = 1;
			if (bWriteMVD)
			{
				unMType += 3;
				if (IsSLFBlock(pCurrMB->BlockType))
				{				
					unMType += 3;
				}
			} 
			unMType += bWriteTCOEFF;
			unMType += bWriteMQuant;

			
			ASSERT(unMType > 1 && unMType < 10);
		}

		ASSERT(unMQuant >= 1 && unMQuant <= 31);
		ASSERT(uBlockCount <= 6);
		pBSInfo->uQuantsTransmittedOnBlocks[unMQuant] += uBlockCount;

		if (bWriteMVD)
		{
			/* Find the preceding motion vectors
			 */
			if ( (unMBA != 1) ||             /* skipped one or more MB */
			     ((unCurrentMB % 11) == 0) ) /* first MB in each row */
			{
				inPrecedingHMV = 0;
				inPrecedingVMV = 0;
			}
			else
			{
				inPrecedingHMV = pLastMB->BlkY1.PHMV;
				inPrecedingVMV = pLastMB->BlkY1.PVMV;
			}
			
			/* adjust vectors:
			 */
			inHDelta = pCurrMB->BlkY1.PHMV - inPrecedingHMV;	
			ASSERT((inHDelta & 0x1) == 0);
			ASSERT((inHDelta >> 1) == (inHDelta / 2));
			inHDelta >>= 1;		 /* Adjust to integer pels */
			if(inHDelta > 15)	 /* Adjust to the range of -16...+15 */
				inHDelta -= 32;
			if(inHDelta < -16)
				inHDelta += 32;
			inHDelta = inHDelta + 16;  /* 0 is at offset 16 */

			inVDelta = pCurrMB->BlkY1.PVMV - inPrecedingVMV;	
			ASSERT((inVDelta & 0x1) == 0);
			ASSERT((inVDelta >> 1) == (inVDelta / 2));
			inVDelta >>= 1;
			if(inVDelta > 15)
				inVDelta -= 32;
			if(inVDelta < -16)
				inVDelta += 32;
			inVDelta = inVDelta + 16;

			#ifndef RING0
			#ifdef DEBUG_PRINTMV
			{
				char buf132[132];
				int iLength;
				
				iLength = wsprintf(buf132, "MB # %d :: H MVD = %d; index = %d :: V MVD = %d; index = %d", unCurrentMB, 
								   pCurrMB->BlkY1.PHMV / 2, inHDelta,
								   pCurrMB->BlkY1.PVMV / 2, inVDelta);
				DBOUT(buf132);
				ASSERT(iLength < 132);
			}
			#endif
			#endif
		}
		else
		{
			/* MBs without MVD need to have zero motion vectors because of 
			 * Rule 3) under 4.2.3.4
			 */
			pCurrMB->BlkY1.PHMV = 0;
			pCurrMB->BlkY1.PVMV = 0;
		}

		/* we should only have MQuant if we have coefficients
		 */
		if (bWriteMQuant)
		{
			ASSERT(bWriteTCOEFF);
		}

		/* we should only have CBP if we have coefficients
		 */
		if (unCBP)
		{
			ASSERT(bWriteTCOEFF);
			ASSERT(uBlockCount > 0);
		}

	    /* Write the MacroBlock Header
		 */

#ifndef RING0
#ifdef DEBUG_MBLK
		{
			int iLength;
			char buf180[180]; 
			iLength = wsprintf(buf180, "Enc #%d: MBType=%ld unNextMQuant=%d MQuant=%ld bWriteMVD=%d MVDH=%ld MVDV=%ld CBP=%ld",
								(int) unCurrentMB,
								unMType, 
								(int) bWriteMQuant, 
								unMQuant,
								(int) bWriteMVD, 
								pCurrMB->BlkY1.PHMV / 2, 
								pCurrMB->BlkY1.PVMV / 2, 
								unCBP);
			DBOUT(buf180);
			ASSERT(iLength < 180);
		}
#endif
#endif
		/* MBA
		 */
	    PutBits(VLC_MBA[unMBA][1], VLC_MBA[unMBA][0], ppu8BitStream, pu8BitOffset);
       
	    /* MTYPE
		 */
		pBSInfo->uMTypeCount[unMType]++;
		pBSInfo->uBlockCount[unMType] += uBlockCount;
		PutBits(VLC_MTYPE[unMType][1], VLC_MTYPE[unMType][0], ppu8BitStream, pu8BitOffset);

		/* MQUANT
		 */
		if (bWriteMQuant) 
		{
			ASSERT(unMQuant > 0 && unMQuant < 32); /* 4.2.2.3 */
			PutBits((int)unMQuant, FIELDLEN_MQUANT, ppu8BitStream, pu8BitOffset);
		}

		/* MVD
		 */
		if (bWriteMVD)
		{
			ASSERT(inHDelta >= 0 && inHDelta < 32);
			ASSERT(inVDelta >= 0 && inVDelta < 32);
			PutBits(VLC_MVD[inHDelta][1], VLC_MVD[inHDelta][0], ppu8BitStream, pu8BitOffset);
			PutBits(VLC_MVD[inVDelta][1], VLC_MVD[inVDelta][0], ppu8BitStream, pu8BitOffset);
		}

		/* CBP
		 */
		if (unCBP != 0)
		{
			PutBits(VLC_CBP[unCBP][1], VLC_CBP[unCBP][0], ppu8BitStream, pu8BitOffset);
		}

		/* TCOEFF
		 */
		if (bWriteTCOEFF) 
		{
			/*
			 * Encode intra DC and all run/val pairs.
			 */
			rvs = MBRunValSign;
			MBEncodeVLC(
				&rvs,
				NULL,
				pCurrMB->CodedBlocks, 
				ppu8BitStream, 
				pu8BitOffset, 
				bIntraBlock,
				FALSE);
		}

		
	} /* for iMBIndex */

  
} /* end of GOB_Q_RLE_VLC_WriteBS() */


void GOB_VLC_WriteBS(
	T_H263EncoderCatalog * EC,
	I8 *pMBRVS_Luma,
	I8 *pMBRVS_Chroma,
	U8 **ppu8BitStream,
	U8 *pu8BitOffset,
	UN  unGQuant,
	UN unStartingMB,
	BOOL bRTPHeader, //RTP: switch
    U32  uGOBNumber         // RTP: info
	)
{
	T_MBlockActionStream *pCurrMB = NULL;
	T_MBlockActionStream *pLastMB = NULL;
	int iMBIndex;
	int iLastMBIndex = -1;
	UN unCurrentMB;
	UN unMBA;
	UN unLastEncodedMBA=0; // RTP: information
    UN unLastCodedMB = 0;    // RTP: information
    UN unCBP;
	UN unMQuant;
	UN unLastEncodedMQuant;
	UN unMType;
	UN bWriteTCOEFF;
	UN bWriteMVD;
	UN bWriteMQuant;
//	I8 MBRunValSign[65*3*6], *pi8EndAddress, *rvs;
	T_MBlockActionStream *pMBActionStream = EC->pU8_MBlockActionStream;
	int bIntraBlock;
  	int	inPrecedingHMV;
  	int inPrecedingVMV;
  	int	inHDelta;
  	int inVDelta;
//	U32 uCumFrmSize;
	U32 uBlockCount;
	ENC_BITSTREAM_INFO * pBSInfo = &EC->BSInfo;
	

	unMQuant = unGQuant;
    unLastEncodedMQuant = unGQuant;
	
	/* Loop through each macroblock of the GOB.
	 */

	pLastMB = NULL;
	pCurrMB = &pMBActionStream[unStartingMB];
	for(iMBIndex = 0 ; iMBIndex < 33; iMBIndex++, pLastMB = pCurrMB++)
	{

		unCurrentMB = unStartingMB + (unsigned int)iMBIndex;

		#ifdef DEBUG_ENC
		wsprintf(string, "MB #%d: QP=%d", unCurrentMB, unMQuant);
		trace(string);
		#endif


		if (bRTPHeader)
        {
            H261RTP_MBUpdateBsInfo(EC, 
				                   pCurrMB, 
								   unLastEncodedMQuant, 
								   (U32 )unLastEncodedMBA, 
								   uGOBNumber,
                                   *ppu8BitStream, 
								   (U32) *pu8BitOffset,
                                   unCurrentMB,
                                   unLastCodedMB
								   );
        }


        EC->uQP_cumulative += unMQuant;
		EC->uQP_count++;

		bWriteMVD = (pCurrMB->BlkY1.PHMV != 0) ||
		  	        (pCurrMB->BlkY1.PVMV != 0) ||
	    			(IsSLFBlock(pCurrMB->BlockType)) ;


	    if (IsInterBlock(pCurrMB->BlockType)) 
		{
			/* Check if the Inter block is not coded?
			 */
			if ( ((pCurrMB->CodedBlocks & 0x3f) == 0) &&
		  	     (! bWriteMVD) )
		    {
				#ifdef DEBUG_MBLK
				wsprintf(string, "Inter MB (index=#%d) has neither Coeff nor MV - skipping", unCurrentMB);
				DBOUT(string);
				#endif
#ifdef FORCE_STUFFING
PutBits(FIELDVAL_MBA_STUFFING, FIELDLEN_MBA_STUFFING, ppu8CurBitStream, pu8BitOffset);
#endif
				continue;
			}
		}

		#ifdef CHECKSUM_MACRO_BLOCK
		/* Write a checksum before all coded blocks
		 */
		WriteMBCheckSum(uCheckSum, EC->pU8_BitStream,ppu8BitStream, pu8BitOffset, unCurrentMB);
		#endif

		/* Calculate the MB header information
		 */

		unMBA = iMBIndex - iLastMBIndex;
		iLastMBIndex = iMBIndex;
		unLastEncodedMBA = unMBA;
        unLastCodedMB = iMBIndex;
        
		
		/* Note: The calculation of whether to write MQuant is done after
		 * skipping macro blocks in order to handle the case that the 11th
		 * or 22nd macro blocks are skipped.  If they are skipped then
		 * the next macro block will be used to write the new quant value.
		 */

	    if(IsIntraBlock(pCurrMB->BlockType))
		{
	        ASSERT(pCurrMB->BlockType == INTRABLOCK);
			if (EC->PictureHeader.PicCodType != INTRAPIC)
			{	        
				pCurrMB->InterCodeCnt = ((U8)unCurrentMB)&0x7;
			} 

			bIntraBlock = 1;
			unCBP = 0;					   /* Never write CBP for Intra blocks */
			uBlockCount = 6;
			bWriteTCOEFF = 1;			   /* Always include TCOEFF for Intra blocks */
			
			/* Since we always have coefficients for Intra MBs we can always update
			 * the MQuant value.
			 */
			//bWriteMQuant = (unMQuant != unLastEncodedMQuant);
			//unLastEncodedMQuant = unMQuant;
			
			bWriteMQuant=0;
			unMType = 0; // + bWriteMQuant;	   /* Calculate MTYPE */
			bWriteMVD = 0;				   /* No motion vectors for INTRA */
		} 
		else
		{
			ASSERT(IsInterBlock(pCurrMB->BlockType));
                
			bIntraBlock = 0;

			unCBP  = (pCurrMB->CodedBlocks & 0x1) << 5;  /* x0 0000 */
			unCBP |= (pCurrMB->CodedBlocks & 0x2) << 3;	 /* 0x 0000 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x4) << 1;	 /* 00 x000 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x8) >> 1;	 /* 00 0x00 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x10) >> 3; /* 00 00x0 */
	    	unCBP |= (pCurrMB->CodedBlocks & 0x20) >> 5; /* 00 000x */

			uBlockCount = 0;
			if (unCBP &  0x1) uBlockCount++;
			if (unCBP &  0x2) uBlockCount++;
			if (unCBP &  0x4) uBlockCount++;
			if (unCBP &  0x8) uBlockCount++;
			if (unCBP & 0x10) uBlockCount++;
			if (unCBP & 0x20) uBlockCount++;

			/* Increment the count if it is transmitted 
			 * "should be forcibly updated at least once every
			 *  132 times it is transmitted" 3.4
			 */
			if (uBlockCount != 0 )
			{
        		pCurrMB->InterCodeCnt++;
			}
	
			bWriteTCOEFF = (unCBP != 0);
		    bWriteMQuant = 0;
			
			#ifdef CHECKSUM_MACRO_BLOCK
			/* Either there are coefficients or the checksum should equal zero
			 */
			ASSERT(bWriteTCOEFF || uCheckSum == 0);
			#endif	

			/* Calculate MType
			 */
		  	unMType = 1;
			if (bWriteMVD)
			{
				unMType += 3;
				if (IsSLFBlock(pCurrMB->BlockType))
				{				
					unMType += 3;
				}
			} 
			unMType += bWriteTCOEFF;
			unMType += bWriteMQuant;

			
			ASSERT(unMType > 1 && unMType < 10);
		}

		ASSERT(unMQuant >= 1 && unMQuant <= 31);
		ASSERT(uBlockCount <= 6);
		pBSInfo->uQuantsTransmittedOnBlocks[unMQuant] += uBlockCount;

		if (bWriteMVD)
		{
			/* Find the preceding motion vectors
			 */
			if ( (unMBA != 1) ||             /* skipped one or more MB */
			     ((unCurrentMB % 11) == 0) ) /* first MB in each row */
			{
				inPrecedingHMV = 0;
				inPrecedingVMV = 0;
			}
			else
			{
				inPrecedingHMV = pLastMB->BlkY1.PHMV;
				inPrecedingVMV = pLastMB->BlkY1.PVMV;
			}
			
			/* adjust vectors:
			 */
			inHDelta = pCurrMB->BlkY1.PHMV - inPrecedingHMV;	
			ASSERT((inHDelta & 0x1) == 0);
			ASSERT((inHDelta >> 1) == (inHDelta / 2));
			inHDelta >>= 1;		 /* Adjust to integer pels */
			if(inHDelta > 15)	 /* Adjust to the range of -16...+15 */
				inHDelta -= 32;
			if(inHDelta < -16)
				inHDelta += 32;
			inHDelta = inHDelta + 16;  /* 0 is at offset 16 */

			inVDelta = pCurrMB->BlkY1.PVMV - inPrecedingVMV;	
			ASSERT((inVDelta & 0x1) == 0);
			ASSERT((inVDelta >> 1) == (inVDelta / 2));
			inVDelta >>= 1;
			if(inVDelta > 15)
				inVDelta -= 32;
			if(inVDelta < -16)
				inVDelta += 32;
			inVDelta = inVDelta + 16;

			#ifndef RING0
			#ifdef DEBUG_PRINTMV
			{
				char buf132[132];
				int iLength;
				
				iLength = wsprintf(buf132, "MB # %d :: H MVD = %d; index = %d :: V MVD = %d; index = %d", unCurrentMB, 
								   pCurrMB->BlkY1.PHMV / 2, inHDelta,
								   pCurrMB->BlkY1.PVMV / 2, inVDelta);
				DBOUT(buf132);
				ASSERT(iLength < 132);
			}
			#endif
			#endif
		}
		else
		{
			/* MBs without MVD need to have zero motion vectors because of 
			 * Rule 3) under 4.2.3.4
			 */
			pCurrMB->BlkY1.PHMV = 0;
			pCurrMB->BlkY1.PVMV = 0;
		}

		/* we should only have MQuant if we have coefficients
		 */
		if (bWriteMQuant)
		{
			ASSERT(bWriteTCOEFF);
		}

		/* we should only have CBP if we have coefficients
		 */
		if (unCBP)
		{
			ASSERT(bWriteTCOEFF);
			ASSERT(uBlockCount > 0);
		}

	    /* Write the MacroBlock Header
		 */

#ifndef RING0
#ifdef DEBUG_MBLK
		{
			int iLength;
			char buf180[180];
			iLength = wsprintf(buf180,
		    "Enc #%d: MBType=%ld bWriteMQuant=%ld MQuant=%ld bWriteMVD=%d MVDH=%ld MVDV=%ld CBP=%ld",
								(int) unCurrentMB,
								unMType, 
								(int) bWriteMQuant, 
								unMQuant,
								(int) bWriteMVD, 
								pCurrMB->BlkY1.PHMV / 2, 
								pCurrMB->BlkY1.PVMV / 2, 
								unCBP);
			DBOUT(buf180);
			ASSERT(iLength < 180);
		}
#endif
#endif
		/* MBA
		 */
	    PutBits(VLC_MBA[unMBA][1], VLC_MBA[unMBA][0], ppu8BitStream, pu8BitOffset);
       
	    /* MTYPE
		 */
		pBSInfo->uMTypeCount[unMType]++;
		pBSInfo->uBlockCount[unMType] += uBlockCount;
		PutBits(VLC_MTYPE[unMType][1], VLC_MTYPE[unMType][0], ppu8BitStream, pu8BitOffset);

		/* MQUANT
		 */
		if (bWriteMQuant) 
		{
			ASSERT(unMQuant > 0 && unMQuant < 32); /* 4.2.2.3 */
			PutBits((int)unMQuant, FIELDLEN_MQUANT, ppu8BitStream, pu8BitOffset);
		}

		/* MVD
		 */
		if (bWriteMVD)
		{
			ASSERT(inHDelta >= 0 && inHDelta < 32);
			ASSERT(inVDelta >= 0 && inVDelta < 32);
			PutBits(VLC_MVD[inHDelta][1], VLC_MVD[inHDelta][0], ppu8BitStream, pu8BitOffset);
			PutBits(VLC_MVD[inVDelta][1], VLC_MVD[inVDelta][0], ppu8BitStream, pu8BitOffset);
		}

		/* CBP
		 */
		if (unCBP != 0)
		{
			PutBits(VLC_CBP[unCBP][1], VLC_CBP[unCBP][0], ppu8BitStream, pu8BitOffset);
		}

		/* TCOEFF
		 */
		if (bWriteTCOEFF) 
		{
			/*
			 * Encode intra DC and all run/val pairs.
			 */
			MBEncodeVLC(
				&pMBRVS_Luma, 
				&pMBRVS_Chroma,
				pCurrMB->CodedBlocks, 
				ppu8BitStream, 
				pu8BitOffset, 
				bIntraBlock,
				1);
		}

		
  } /* for iMBIndex */
  

} /* end of GOB_VLC_WriteBS() */





/*****************************************************************************
 *
 *  MB_Quantize_RLE
 *
 *  Takes the list of coefficient pairs from the DCT routine and returns a list 
 *  of Run/Level/Sign triples (each 1 byte).  The end of the run/level/sign 
 *  triples for a block is signalled by an illegal combination (TBD).
 */
static I8 * MB_Quantize_RLE(
		I32 ** ppiDCTCoefs,
		I8 * pi8MBRunValTriplets,
		U8 * pu8CodedBlocks,
		U8 u8BlockType,
		I32 iQP,
		U32 * puCheckSum
		)
{
	I32 iBlockNumber;
	U8 u8Bitmask = 1;
	I8 * pi8EndAddress;
	U32 uCheckSum;

	#ifdef DEBUG_DCT
	int  iDCTArray[64];
	#endif

	/*
	 * Loop through all 6 blocks of macroblock.
	 */
	uCheckSum = 0;
	for(iBlockNumber = 0; iBlockNumber < 6; iBlockNumber++, u8Bitmask <<= 1)
	{

		#ifdef DEBUG_ENC
		wsprintf(string, "Block #%d", iBlockNumber);
		trace(string);
		#endif

		/* Skip this block if not coded.
		 */
		if( (*pu8CodedBlocks & u8Bitmask) == 0)
		{
			continue;
		}

		#ifdef DEBUG_DCT
		cnvt_fdct_output((unsigned short *) *ppiDCTCoefs, iDCTArray, IsIntraBlock(u8BlockType));
		#endif
	
		/*
		 * Quantize and run-length encode a block.
		 */  
	    pi8EndAddress = QUANTRLE(*ppiDCTCoefs, pi8MBRunValTriplets, iQP, (I32)u8BlockType);

		#ifdef DEBUG_ENC
		I8 * pi8;
		for(pi8 = pi8MBRunValTriplets; pi8 < pi8EndAddress; pi8+=3)
		{
			wsprintf(string, "(%u, %u, %d)", (unsigned char)*pi8, (unsigned char)*(pi8+1), (int)*(pi8+2) );
			trace(string);
		}
		#endif
		#ifdef CHECKSUM_MACRO_BLOCK
		uCheckSum += ComputeCheckSum(pi8MBRunValTriplets, pi8EndAddress, iBlockNumber);
		#endif

		/* Clear coded block bit for this block.
		 */
		if ( pi8EndAddress == pi8MBRunValTriplets)
		{
			ASSERT(u8BlockType != INTRABLOCK)	/* should have at least INTRADC in an INTRA blck */
			*pu8CodedBlocks &= ~u8Bitmask;
		}
		else if ( (pi8EndAddress == (pi8MBRunValTriplets+3)) && (u8BlockType == INTRABLOCK) )
		{
			*pu8CodedBlocks &= ~u8Bitmask;
			pi8MBRunValTriplets = pi8EndAddress;
		}
		else
		{
			pi8MBRunValTriplets = pi8EndAddress;
			*pi8MBRunValTriplets = -1;		/* Assign an illegal run to signal end of block. */
			pi8MBRunValTriplets += 3;		/* Increment to the next triple. */
		}

		/*  Increment DCT Coefficient pointer to next block.
		 */
		*ppiDCTCoefs += 32;		
	}

	*puCheckSum = uCheckSum;

	return pi8MBRunValTriplets;

} /* end MB_Quantize_RLE() */


void InitVLC(void)
{
  int i;
  int run, level;

  /*
   * initialize INTRADC fixed length code table.
   */
  for(i = 1; i < 254; i++)
  {
    FLC_INTRADC[i] = i;
  }
  FLC_INTRADC[0] = 1;
  FLC_INTRADC[128] = 255;
  FLC_INTRADC[254] = 254;
  FLC_INTRADC[255] = 254;

 /*
  * Initialize tcoef tables.
  */

   for(i = 0; i < (NUMBER_OF_TCOEF_ENTRIES); i++) {
      VLC_TCOEF_TBL[i] = 0x0000FFFF;
   }
  
   for(run = 0; run < 64; run++) {
      for(level = 1; level <= TCOEF_RUN_MAXLEVEL[run].maxlevel; level++) {
         DWORD dwSize, dwCode;

         dwSize = *(TCOEF_RUN_MAXLEVEL[run].ptable + (level - 1) * 2);
         dwSize <<= 16;
         dwCode = *(TCOEF_RUN_MAXLEVEL[run].ptable + (level - 1) * 2 + 1);

         VLC_TCOEF_TBL[run + (level - 1) * 64] = dwCode;
         VLC_TCOEF_TBL[run + (level - 1) * 64] |= dwSize;
	   } // end of for level
   } // end of for run

} // InitVLC.


#ifdef CHECKSUM_MACRO_BLOCK
/*****************************************************************************
 *
 *  ComputeCheckSum
 *
 *  Compute the checksum for this block
 */
static U32 ComputeCheckSum(
	I8 * pi8MBRunValTriplets,
	I8 * pi8EndAddress,
	I32 iBlockNumber)
{
	I8 * pi8;
	U32 uRun;
	U32 uLevel;
	I32 iSign;
	U32 uSignBit;
	U32 uCheckSum = 0;
	#if CHECKSUM_MACRO_BLOCK_DETAIL
	char buf80[80];
	int iLength;
	#endif
	
	for (pi8 = pi8MBRunValTriplets; pi8 < pi8EndAddress; )
	{
		uRun = (U32)*pi8++;
		uLevel = (U32)(U8)*pi8++;
		iSign = (I32)*pi8++;
		if (iSign == 0) 
		{
			uSignBit = 0;
		}
		else
		{
			ASSERT(iSign == 0xFFFFFFFF);
			uSignBit = 1;
		}

		uCheckSum += uRun << 24;
		uCheckSum += uLevel << 8;
		uCheckSum += uSignBit;

		#ifdef CHECKSUM_MACRO_BLOCK_DETAIL
		iLength = wsprintf(buf80,"Block=%d R=0x%x L=0x%x S=%d, CheckSum=0x%x", iBlockNumber, uRun, uLevel, uSignBit, uCheckSum);
		DBOUT(buf80);
		ASSERT(iLength < 80);
		#endif
	}
	
	return uCheckSum;
} /* end ComputeCheckSum() */


/*****************************************************************************
 *
 *  WriteMBCheckSum
 *
 *  Write the macro block checksum information.
 */
static void WriteMBCheckSum(
	U32 uCheckSum,
	U8 * pu8PictureStart, 
	U8 ** ppu8BitStream, 
	U8 * pu8BitOffset,
	UN unCurrentMB)
{
	U32 uBytes;
	U32 uTempBytes;
	U8 u8Bits;
	U8 u8TempBits;
	UN unCount;
	UN unKey;
	UN unData;

	uBytes = *ppu8BitStream - pu8PictureStart;
	u8Bits = *pu8BitOffset;

	/* Add in the space for the checksum info (eleven 8-bit fields + 12 "1"s + MBA stuffing)
	 */
	uBytes += 12;
	u8Bits += 4 + FIELDLEN_MBA_STUFFING;

	/* Adjust bits to < 7 
	 */
	while (u8Bits > 7)
	{
		u8Bits -= 8;
		uBytes++;
	}

	#if _DEBUG
	#if CHECKSUM_MACRO_BLOCK_DETAIL
	{
	char buf80[80];
	int iLength;

	iLength = wsprintf(buf80,"MB=%d CHK=0x%x Bytes=%ld Bits=%d", unCurrentMB, uCheckSum, uBytes, (int) u8Bits);
	DBOUT(buf80);
	ASSERT(iLength < 80);
	}
	#endif
	#endif

	/* Write the MBASTUFFING value 
	 */
	PutBits(FIELDVAL_MBA_STUFFING, FIELDLEN_MBA_STUFFING, ppu8BitStream, pu8BitOffset);

	/* Write the data to the bitstream
	 */

	/* Key - a value of 1 in an 8-bit field following a "1"
	 */
	unKey = 1;
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unKey, 8, ppu8BitStream, pu8BitOffset);
	
	/* Count - number of bits after the Count field.
	 */
	unCount = 9*8 + 10*1;  /* nine 8-bit value and 10 "1"s. */
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unCount, 8, ppu8BitStream, pu8BitOffset);

	/* Bytes - high to low bytes
	 */
	unData = (UN) ((uBytes >> 24) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) ((uBytes >> 16) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) ((uBytes >> 8) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) (uBytes & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	/* Bits
	 */
	unData = (UN) u8Bits;
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	/* Checksum - high to low bytes
	 */
	unData = (UN) ((uCheckSum >> 24) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) ((uCheckSum >> 16) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) ((uCheckSum >> 8) & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	unData = (UN) (uCheckSum & 0xFF);
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);
	PutBits(unData, 8, ppu8BitStream, pu8BitOffset);

	/* Trailing 1 bit to avoid start code duplication.
	 */
	PutBits(1, 1, ppu8BitStream, pu8BitOffset);

	/* Check that the pointers are correct
	 */
	uTempBytes = *ppu8BitStream - pu8PictureStart;
	u8TempBits = *pu8BitOffset;

	while (u8TempBits > 7) 
	{
		u8TempBits -= 8;
		uTempBytes++;
	}

	ASSERT(uTempBytes == uBytes);
	ASSERT(u8TempBits == u8Bits);

} /* end WriteMBCheckSum() */

#endif