public static size_t HUF_readDTableX2_wksp()

in csharp/src/HufDecompress.cs [117:180]


		public static size_t HUF_readDTableX2_wksp(HUF_DTable* DTable, void* src, size_t srcSize, void* workSpace, size_t wkspSize)
		{
			U32 tableLog = 0;
			U32 nbSymbols = 0;
			size_t iSize;
			void* dtPtr = DTable + 1;
			HUF_DEltX2* dt = (HUF_DEltX2*)dtPtr;

			U32* rankVal;
			BYTE* huffWeight;
			size_t spaceUsed32 = 0;

			rankVal = (U32*)workSpace + spaceUsed32;
			spaceUsed32 += HUF_TABLELOG_ABSOLUTEMAX + 1;
			huffWeight = (BYTE*)((U32*)workSpace + spaceUsed32);
			spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2;

			if ((spaceUsed32 << 2) > wkspSize) return ERROR(Error.tableLog_tooLarge);

			//HUF_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
			/* memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */

			iSize = ReadStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
			if (IsError(iSize)) return iSize;

			/* Table header */
			{
				DTableDesc dtd = GetDTableDesc(DTable);
				if (tableLog > (U32)(dtd.maxTableLog + 1)) return ERROR(Error.tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
				dtd.tableType = 0;
				dtd.tableLog = (BYTE)tableLog;
				*(DTableDesc*)DTable = dtd; // memcpy(DTable, &dtd, sizeof(dtd));
			}

			/* Calculate starting value for each rank */
			{
				U32 n, nextRankStart = 0;
				for (n = 1; n < tableLog + 1; n++)
				{
					U32 current = nextRankStart;
					nextRankStart += (rankVal[n] << (int)(n - 1));
					rankVal[n] = current;
				}
			}

			/* fill DTable */
			{
				U32 n;
				for (n = 0; n < nbSymbols; n++)
				{
					U32 w = huffWeight[n];
					U32 length = ((U32)1 << (int)w) >> 1;
					U32 u;
					HUF_DEltX2 D;
					D.byteField = (BYTE)n;
					D.nbBits = (BYTE)(tableLog + 1 - w);
					for (u = rankVal[w]; u < rankVal[w] + length; u++)
						dt[u] = D;
					rankVal[w] += length;
				}
			}

			return iSize;
		}