Print done when done.

1 files changed, 390 insertions, 0 deletions

diff --git a/indra/llmessage/patch_code.cpp b/indra/llmessage/patch_code.cpp
new file mode 100644
index 0000000000..c8ebac53e7
--- /dev/null
+++ b/indra/llmessage/patch_code.cpp
@@ -0,0 +1,390 @@
+/** 
+ * @file patch_code.cpp
+ * @brief Encode patch DCT data into bitcode.
+ *
+ * Copyright (c) 2000-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "linden_common.h"
+
+#include "llmath.h"
+//#include "vmath.h"
+#include "v3math.h"
+#include "patch_dct.h"
+#include "patch_code.h"
+#include "bitpack.h"
+
+U32 gPatchSize, gWordBits;
+
+void	init_patch_coding(LLBitPack &bitpack)
+{
+	bitpack.resetBitPacking();
+}
+
+void	code_patch_group_header(LLBitPack &bitpack, LLGroupHeader *gopp)
+{
+#ifdef LL_BIG_ENDIAN
+	U8 *stride = (U8 *)&gopp->stride;
+	bitpack.bitPack(&(stride[1]), 8);
+	bitpack.bitPack(&(stride[0]), 8);
+#else
+	bitpack.bitPack((U8 *)&gopp->stride, 16);
+#endif
+	bitpack.bitPack((U8 *)&gopp->patch_size, 8);
+	bitpack.bitPack((U8 *)&gopp->layer_type, 8);
+
+	gPatchSize = gopp->patch_size; 
+}
+
+void	code_patch_header(LLBitPack &bitpack, LLPatchHeader *ph, S32 *patch)
+{
+	S32		i, j, temp, patch_size = gPatchSize, wbits = (ph->quant_wbits & 0xf) + 2;
+	U32     max_wbits = wbits + 5, min_wbits = wbits>>1;
+
+	wbits = min_wbits;
+
+	for (i = 0; i < (int) patch_size*patch_size; i++)
+	{
+		temp = patch[i];
+		if (temp)
+		{
+			if (temp < 0)
+				temp *= -1;
+			for (j = max_wbits; j > (int) min_wbits; j--)
+			{
+				if (temp & (1<<j))
+				{
+					if (j > wbits)
+						wbits = j;
+					break;
+				}
+			}
+		}
+	}
+
+	wbits += 1;
+
+	ph->quant_wbits &= 0xf0;
+
+	if (  (wbits > 17)
+		||(wbits < 2))
+	{
+		llerrs << "Bits needed per word in code_patch_header out of legal range.  Adjust compression quatization." << llendl;
+	}
+
+	ph->quant_wbits |= (wbits - 2);
+
+	bitpack.bitPack((U8 *)&ph->quant_wbits, 8);
+#ifdef LL_BIG_ENDIAN
+	U8 *offset = (U8 *)&ph->dc_offset;
+	bitpack.bitPack(&(offset[3]), 8);
+	bitpack.bitPack(&(offset[2]), 8);
+	bitpack.bitPack(&(offset[1]), 8);
+	bitpack.bitPack(&(offset[0]), 8);
+#else
+	bitpack.bitPack((U8 *)&ph->dc_offset, 32);
+#endif
+#ifdef LL_BIG_ENDIAN
+	U8 *range = (U8 *)&ph->range;
+	bitpack.bitPack(&(range[1]), 8);
+	bitpack.bitPack(&(range[0]), 8);
+#else
+	bitpack.bitPack((U8 *)&ph->range, 16);
+#endif
+#ifdef LL_BIG_ENDIAN
+	U8 *ids = (U8 *)&ph->patchids;
+	bitpack.bitPack(&(ids[1]), 8);
+	bitpack.bitPack(&(ids[0]), 2);
+#else
+	bitpack.bitPack((U8 *)&ph->patchids, 10);
+#endif
+
+	gWordBits = wbits;
+}
+
+void	code_end_of_data(LLBitPack &bitpack)
+{
+	bitpack.bitPack((U8 *)&END_OF_PATCHES, 8);
+}
+
+void code_patch(LLBitPack &bitpack, S32 *patch, S32 postquant)
+{
+	S32		i, j, patch_size = gPatchSize, wbits = gWordBits;
+	S32		temp;
+	BOOL	b_eob;
+
+	if (  (postquant > patch_size*patch_size)
+		||(postquant < 0))
+	{
+		llerrs << "Bad postquant in code_patch!"  << llendl;
+	}
+
+	if (postquant)
+		patch[patch_size*patch_size - postquant] = 0;
+
+	for (i = 0; i < patch_size*patch_size; i++)
+	{
+		b_eob = FALSE;
+		temp = patch[i];
+		if (!temp)
+		{
+			b_eob = TRUE;
+			for (j = i; j < patch_size*patch_size - postquant; j++)
+			{
+				if (patch[j])
+				{
+					b_eob = FALSE;
+					break;
+				}
+			}
+			if (b_eob)
+			{
+				bitpack.bitPack((U8 *)&ZERO_EOB, 2);
+				return;
+			}
+			else
+			{
+				bitpack.bitPack((U8 *)&ZERO_CODE, 1);
+			}
+		}
+		else
+		{
+			if (temp < 0)
+			{
+				temp *= -1;
+				if (temp > (1<<wbits))
+				{
+					temp = (1<<wbits);
+//					printf("patch quatization exceeding allowable bits!");
+				}
+				bitpack.bitPack((U8 *)&NEGATIVE_VALUE, 3);
+				bitpack.bitPack((U8 *)&temp, wbits);
+			}
+			else
+			{
+				if (temp > (1<<wbits))
+				{
+					temp = (1<<wbits);
+//					printf("patch quatization exceeding allowable bits!");
+				}
+				bitpack.bitPack((U8 *)&POSITIVE_VALUE, 3);
+				bitpack.bitPack((U8 *)&temp, wbits);
+			}
+		}
+	}
+}
+
+
+void	end_patch_coding(LLBitPack &bitpack)
+{
+	bitpack.flushBitPack();
+}
+
+void	init_patch_decoding(LLBitPack &bitpack)
+{
+	bitpack.resetBitPacking();
+}
+
+void	decode_patch_group_header(LLBitPack &bitpack, LLGroupHeader *gopp)
+{
+	U16 retvalu16;
+
+	retvalu16 = 0;
+#ifdef LL_BIG_ENDIAN
+	U8 *ret = (U8 *)&retvalu16;
+	bitpack.bitUnpack(&(ret[1]), 8);
+	bitpack.bitUnpack(&(ret[0]), 8);
+#else
+	bitpack.bitUnpack((U8 *)&retvalu16, 16);
+#endif
+	gopp->stride = retvalu16;
+
+	U8 retvalu8 = 0;
+	bitpack.bitUnpack(&retvalu8, 8);
+	gopp->patch_size = retvalu8;
+
+	retvalu8 = 0;
+	bitpack.bitUnpack(&retvalu8, 8);
+	gopp->layer_type = retvalu8;
+
+	gPatchSize = gopp->patch_size; 
+}
+
+void	decode_patch_header(LLBitPack &bitpack, LLPatchHeader *ph)
+{
+	U8 retvalu8;
+
+	retvalu8 = 0;
+	bitpack.bitUnpack(&retvalu8, 8);
+	ph->quant_wbits = retvalu8;
+
+	if (END_OF_PATCHES == ph->quant_wbits)
+	{
+		// End of data, blitz the rest.
+		ph->dc_offset = 0;
+		ph->range = 0;
+		ph->patchids = 0;
+		return;
+	}
+
+	U32 retvalu32 = 0;
+#ifdef LL_BIG_ENDIAN
+	U8 *ret = (U8 *)&retvalu32;
+	bitpack.bitUnpack(&(ret[3]), 8);
+	bitpack.bitUnpack(&(ret[2]), 8);
+	bitpack.bitUnpack(&(ret[1]), 8);
+	bitpack.bitUnpack(&(ret[0]), 8);
+#else
+	bitpack.bitUnpack((U8 *)&retvalu32, 32);
+#endif
+	ph->dc_offset = *(F32 *)&retvalu32;
+
+	U16 retvalu16 = 0;
+#ifdef LL_BIG_ENDIAN
+	ret = (U8 *)&retvalu16;
+	bitpack.bitUnpack(&(ret[1]), 8);
+	bitpack.bitUnpack(&(ret[0]), 8);
+#else
+	bitpack.bitUnpack((U8 *)&retvalu16, 16);
+#endif
+	ph->range = retvalu16;
+
+	retvalu16 = 0;
+#ifdef LL_BIG_ENDIAN
+	ret = (U8 *)&retvalu16;
+	bitpack.bitUnpack(&(ret[1]), 8);
+	bitpack.bitUnpack(&(ret[0]), 2);
+#else
+	bitpack.bitUnpack((U8 *)&retvalu16, 10);
+#endif
+	ph->patchids = retvalu16;
+
+	gWordBits = (ph->quant_wbits & 0xf) + 2;
+}
+
+void	decode_patch(LLBitPack &bitpack, S32 *patches)
+{
+#ifdef LL_BIG_ENDIAN
+	S32		i, j, patch_size = gPatchSize, wbits = gWordBits;
+	U8		tempu8;
+	U16		tempu16;
+	U32		tempu32;
+	for (i = 0; i < patch_size*patch_size; i++)
+	{
+		bitpack.bitUnpack((U8 *)&tempu8, 1);
+		if (tempu8)
+		{
+			// either 0 EOB or Value
+			bitpack.bitUnpack((U8 *)&tempu8, 1);
+			if (tempu8)
+			{
+				// value
+				bitpack.bitUnpack((U8 *)&tempu8, 1);
+				if (tempu8)
+				{
+					// negative
+					patches[i] = -1;
+				}
+				else
+				{
+					// positive
+					patches[i] = 1;
+				}
+				if (wbits <= 8)
+				{
+					bitpack.bitUnpack((U8 *)&tempu8, wbits);
+					patches[i] *= tempu8;
+				}
+				else if (wbits <= 16)
+				{
+					tempu16 = 0;
+					U8 *ret = (U8 *)&tempu16;
+					bitpack.bitUnpack(&(ret[1]), 8);
+					bitpack.bitUnpack(&(ret[0]), wbits - 8);
+					patches[i] *= tempu16;
+				}
+				else if (wbits <= 24)
+				{
+					tempu32 = 0;
+					U8 *ret = (U8 *)&tempu32;
+					bitpack.bitUnpack(&(ret[2]), 8);
+					bitpack.bitUnpack(&(ret[1]), 8);
+					bitpack.bitUnpack(&(ret[0]), wbits - 16);
+					patches[i] *= tempu32;
+				}
+				else if (wbits <= 32)
+				{
+					tempu32 = 0;
+					U8 *ret = (U8 *)&tempu32;
+					bitpack.bitUnpack(&(ret[3]), 8);
+					bitpack.bitUnpack(&(ret[2]), 8);
+					bitpack.bitUnpack(&(ret[1]), 8);
+					bitpack.bitUnpack(&(ret[0]), wbits - 24);
+					patches[i] *= tempu32;
+				}
+			}
+			else
+			{
+				for (j = i; j < patch_size*patch_size; j++)
+				{
+					patches[j] = 0;
+				}
+				return;
+			}
+		}
+		else
+		{
+			patches[i] = 0;
+		}
+	}
+#else
+	S32		i, j, patch_size = gPatchSize, wbits = gWordBits;
+	U32		temp;
+	for (i = 0; i < patch_size*patch_size; i++)
+	{
+		temp = 0;
+		bitpack.bitUnpack((U8 *)&temp, 1);
+		if (temp)
+		{
+			// either 0 EOB or Value
+			temp = 0;
+			bitpack.bitUnpack((U8 *)&temp, 1);
+			if (temp)
+			{
+				// value
+				temp = 0;
+				bitpack.bitUnpack((U8 *)&temp, 1);
+				if (temp)
+				{
+					// negative
+					temp = 0;
+					bitpack.bitUnpack((U8 *)&temp, wbits);
+					patches[i] = temp;
+					patches[i] *= -1;
+				}
+				else
+				{
+					// positive
+					temp = 0;
+					bitpack.bitUnpack((U8 *)&temp, wbits);
+					patches[i] = temp;
+				}
+			}
+			else
+			{
+				for (j = i; j < patch_size*patch_size; j++)
+				{
+					patches[j] = 0;
+				}
+				return;
+			}
+		}
+		else
+		{
+			patches[i] = 0;
+		}
+	}
+#endif
+}
+