796 lines
24 KiB
C
Executable file
796 lines
24 KiB
C
Executable file
/*
|
|
* FSE : Finite State Entropy encoder
|
|
* Copyright (C) 2013-2015, Yann Collet.
|
|
*
|
|
* BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following disclaimer
|
|
* in the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License version 2 as published by the
|
|
* Free Software Foundation. This program is dual-licensed; you may select
|
|
* either version 2 of the GNU General Public License ("GPL") or BSD license
|
|
* ("BSD").
|
|
*
|
|
* You can contact the author at :
|
|
* - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
|
|
*/
|
|
|
|
/* **************************************************************
|
|
* Compiler specifics
|
|
****************************************************************/
|
|
#define FORCE_INLINE static __always_inline
|
|
|
|
/* **************************************************************
|
|
* Includes
|
|
****************************************************************/
|
|
#include "bitstream.h"
|
|
#include "fse.h"
|
|
#include <linux/compiler.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/math64.h>
|
|
#include <linux/string.h> /* memcpy, memset */
|
|
|
|
/* **************************************************************
|
|
* Error Management
|
|
****************************************************************/
|
|
#define FSE_STATIC_ASSERT(c) \
|
|
{ \
|
|
enum { FSE_static_assert = 1 / (int)(!!(c)) }; \
|
|
} /* use only *after* variable declarations */
|
|
|
|
/* **************************************************************
|
|
* Templates
|
|
****************************************************************/
|
|
/*
|
|
designed to be included
|
|
for type-specific functions (template emulation in C)
|
|
Objective is to write these functions only once, for improved maintenance
|
|
*/
|
|
|
|
/* safety checks */
|
|
#ifndef FSE_FUNCTION_EXTENSION
|
|
#error "FSE_FUNCTION_EXTENSION must be defined"
|
|
#endif
|
|
#ifndef FSE_FUNCTION_TYPE
|
|
#error "FSE_FUNCTION_TYPE must be defined"
|
|
#endif
|
|
|
|
/* Function names */
|
|
#define FSE_CAT(X, Y) X##Y
|
|
#define FSE_FUNCTION_NAME(X, Y) FSE_CAT(X, Y)
|
|
#define FSE_TYPE_NAME(X, Y) FSE_CAT(X, Y)
|
|
|
|
/* Function templates */
|
|
|
|
/* FSE_buildCTable_wksp() :
|
|
* Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
|
|
* wkspSize should be sized to handle worst case situation, which is `1<<max_tableLog * sizeof(FSE_FUNCTION_TYPE)`
|
|
* workSpace must also be properly aligned with FSE_FUNCTION_TYPE requirements
|
|
*/
|
|
size_t FSE_buildCTable_wksp(FSE_CTable *ct, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void *workspace, size_t workspaceSize)
|
|
{
|
|
U32 const tableSize = 1 << tableLog;
|
|
U32 const tableMask = tableSize - 1;
|
|
void *const ptr = ct;
|
|
U16 *const tableU16 = ((U16 *)ptr) + 2;
|
|
void *const FSCT = ((U32 *)ptr) + 1 /* header */ + (tableLog ? tableSize >> 1 : 1);
|
|
FSE_symbolCompressionTransform *const symbolTT = (FSE_symbolCompressionTransform *)(FSCT);
|
|
U32 const step = FSE_TABLESTEP(tableSize);
|
|
U32 highThreshold = tableSize - 1;
|
|
|
|
U32 *cumul;
|
|
FSE_FUNCTION_TYPE *tableSymbol;
|
|
size_t spaceUsed32 = 0;
|
|
|
|
cumul = (U32 *)workspace + spaceUsed32;
|
|
spaceUsed32 += FSE_MAX_SYMBOL_VALUE + 2;
|
|
tableSymbol = (FSE_FUNCTION_TYPE *)((U32 *)workspace + spaceUsed32);
|
|
spaceUsed32 += ALIGN(sizeof(FSE_FUNCTION_TYPE) * ((size_t)1 << tableLog), sizeof(U32)) >> 2;
|
|
|
|
if ((spaceUsed32 << 2) > workspaceSize)
|
|
return ERROR(tableLog_tooLarge);
|
|
workspace = (U32 *)workspace + spaceUsed32;
|
|
workspaceSize -= (spaceUsed32 << 2);
|
|
|
|
/* CTable header */
|
|
tableU16[-2] = (U16)tableLog;
|
|
tableU16[-1] = (U16)maxSymbolValue;
|
|
|
|
/* For explanations on how to distribute symbol values over the table :
|
|
* http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
|
|
|
|
/* symbol start positions */
|
|
{
|
|
U32 u;
|
|
cumul[0] = 0;
|
|
for (u = 1; u <= maxSymbolValue + 1; u++) {
|
|
if (normalizedCounter[u - 1] == -1) { /* Low proba symbol */
|
|
cumul[u] = cumul[u - 1] + 1;
|
|
tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u - 1);
|
|
} else {
|
|
cumul[u] = cumul[u - 1] + normalizedCounter[u - 1];
|
|
}
|
|
}
|
|
cumul[maxSymbolValue + 1] = tableSize + 1;
|
|
}
|
|
|
|
/* Spread symbols */
|
|
{
|
|
U32 position = 0;
|
|
U32 symbol;
|
|
for (symbol = 0; symbol <= maxSymbolValue; symbol++) {
|
|
int nbOccurences;
|
|
for (nbOccurences = 0; nbOccurences < normalizedCounter[symbol]; nbOccurences++) {
|
|
tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
|
|
position = (position + step) & tableMask;
|
|
while (position > highThreshold)
|
|
position = (position + step) & tableMask; /* Low proba area */
|
|
}
|
|
}
|
|
|
|
if (position != 0)
|
|
return ERROR(GENERIC); /* Must have gone through all positions */
|
|
}
|
|
|
|
/* Build table */
|
|
{
|
|
U32 u;
|
|
for (u = 0; u < tableSize; u++) {
|
|
FSE_FUNCTION_TYPE s = tableSymbol[u]; /* note : static analyzer may not understand tableSymbol is properly initialized */
|
|
tableU16[cumul[s]++] = (U16)(tableSize + u); /* TableU16 : sorted by symbol order; gives next state value */
|
|
}
|
|
}
|
|
|
|
/* Build Symbol Transformation Table */
|
|
{
|
|
unsigned total = 0;
|
|
unsigned s;
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
switch (normalizedCounter[s]) {
|
|
case 0: break;
|
|
|
|
case -1:
|
|
case 1:
|
|
symbolTT[s].deltaNbBits = (tableLog << 16) - (1 << tableLog);
|
|
symbolTT[s].deltaFindState = total - 1;
|
|
total++;
|
|
break;
|
|
default: {
|
|
U32 const maxBitsOut = tableLog - BIT_highbit32(normalizedCounter[s] - 1);
|
|
U32 const minStatePlus = normalizedCounter[s] << maxBitsOut;
|
|
symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
|
|
symbolTT[s].deltaFindState = total - normalizedCounter[s];
|
|
total += normalizedCounter[s];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*-**************************************************************
|
|
* FSE NCount encoding-decoding
|
|
****************************************************************/
|
|
size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
|
|
{
|
|
size_t const maxHeaderSize = (((maxSymbolValue + 1) * tableLog) >> 3) + 3;
|
|
return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND; /* maxSymbolValue==0 ? use default */
|
|
}
|
|
|
|
static size_t FSE_writeNCount_generic(void *header, size_t headerBufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
|
|
unsigned writeIsSafe)
|
|
{
|
|
BYTE *const ostart = (BYTE *)header;
|
|
BYTE *out = ostart;
|
|
BYTE *const oend = ostart + headerBufferSize;
|
|
int nbBits;
|
|
const int tableSize = 1 << tableLog;
|
|
int remaining;
|
|
int threshold;
|
|
U32 bitStream;
|
|
int bitCount;
|
|
unsigned charnum = 0;
|
|
int previous0 = 0;
|
|
|
|
bitStream = 0;
|
|
bitCount = 0;
|
|
/* Table Size */
|
|
bitStream += (tableLog - FSE_MIN_TABLELOG) << bitCount;
|
|
bitCount += 4;
|
|
|
|
/* Init */
|
|
remaining = tableSize + 1; /* +1 for extra accuracy */
|
|
threshold = tableSize;
|
|
nbBits = tableLog + 1;
|
|
|
|
while (remaining > 1) { /* stops at 1 */
|
|
if (previous0) {
|
|
unsigned start = charnum;
|
|
while (!normalizedCounter[charnum])
|
|
charnum++;
|
|
while (charnum >= start + 24) {
|
|
start += 24;
|
|
bitStream += 0xFFFFU << bitCount;
|
|
if ((!writeIsSafe) && (out > oend - 2))
|
|
return ERROR(dstSize_tooSmall); /* Buffer overflow */
|
|
out[0] = (BYTE)bitStream;
|
|
out[1] = (BYTE)(bitStream >> 8);
|
|
out += 2;
|
|
bitStream >>= 16;
|
|
}
|
|
while (charnum >= start + 3) {
|
|
start += 3;
|
|
bitStream += 3 << bitCount;
|
|
bitCount += 2;
|
|
}
|
|
bitStream += (charnum - start) << bitCount;
|
|
bitCount += 2;
|
|
if (bitCount > 16) {
|
|
if ((!writeIsSafe) && (out > oend - 2))
|
|
return ERROR(dstSize_tooSmall); /* Buffer overflow */
|
|
out[0] = (BYTE)bitStream;
|
|
out[1] = (BYTE)(bitStream >> 8);
|
|
out += 2;
|
|
bitStream >>= 16;
|
|
bitCount -= 16;
|
|
}
|
|
}
|
|
{
|
|
int count = normalizedCounter[charnum++];
|
|
int const max = (2 * threshold - 1) - remaining;
|
|
remaining -= count < 0 ? -count : count;
|
|
count++; /* +1 for extra accuracy */
|
|
if (count >= threshold)
|
|
count += max; /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
|
|
bitStream += count << bitCount;
|
|
bitCount += nbBits;
|
|
bitCount -= (count < max);
|
|
previous0 = (count == 1);
|
|
if (remaining < 1)
|
|
return ERROR(GENERIC);
|
|
while (remaining < threshold)
|
|
nbBits--, threshold >>= 1;
|
|
}
|
|
if (bitCount > 16) {
|
|
if ((!writeIsSafe) && (out > oend - 2))
|
|
return ERROR(dstSize_tooSmall); /* Buffer overflow */
|
|
out[0] = (BYTE)bitStream;
|
|
out[1] = (BYTE)(bitStream >> 8);
|
|
out += 2;
|
|
bitStream >>= 16;
|
|
bitCount -= 16;
|
|
}
|
|
}
|
|
|
|
/* flush remaining bitStream */
|
|
if ((!writeIsSafe) && (out > oend - 2))
|
|
return ERROR(dstSize_tooSmall); /* Buffer overflow */
|
|
out[0] = (BYTE)bitStream;
|
|
out[1] = (BYTE)(bitStream >> 8);
|
|
out += (bitCount + 7) / 8;
|
|
|
|
if (charnum > maxSymbolValue + 1)
|
|
return ERROR(GENERIC);
|
|
|
|
return (out - ostart);
|
|
}
|
|
|
|
size_t FSE_writeNCount(void *buffer, size_t bufferSize, const short *normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
|
|
{
|
|
if (tableLog > FSE_MAX_TABLELOG)
|
|
return ERROR(tableLog_tooLarge); /* Unsupported */
|
|
if (tableLog < FSE_MIN_TABLELOG)
|
|
return ERROR(GENERIC); /* Unsupported */
|
|
|
|
if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
|
|
return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
|
|
|
|
return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1);
|
|
}
|
|
|
|
/*-**************************************************************
|
|
* Counting histogram
|
|
****************************************************************/
|
|
/*! FSE_count_simple
|
|
This function counts byte values within `src`, and store the histogram into table `count`.
|
|
It doesn't use any additional memory.
|
|
But this function is unsafe : it doesn't check that all values within `src` can fit into `count`.
|
|
For this reason, prefer using a table `count` with 256 elements.
|
|
@return : count of most numerous element
|
|
*/
|
|
size_t FSE_count_simple(unsigned *count, unsigned *maxSymbolValuePtr, const void *src, size_t srcSize)
|
|
{
|
|
const BYTE *ip = (const BYTE *)src;
|
|
const BYTE *const end = ip + srcSize;
|
|
unsigned maxSymbolValue = *maxSymbolValuePtr;
|
|
unsigned max = 0;
|
|
|
|
memset(count, 0, (maxSymbolValue + 1) * sizeof(*count));
|
|
if (srcSize == 0) {
|
|
*maxSymbolValuePtr = 0;
|
|
return 0;
|
|
}
|
|
|
|
while (ip < end)
|
|
count[*ip++]++;
|
|
|
|
while (!count[maxSymbolValue])
|
|
maxSymbolValue--;
|
|
*maxSymbolValuePtr = maxSymbolValue;
|
|
|
|
{
|
|
U32 s;
|
|
for (s = 0; s <= maxSymbolValue; s++)
|
|
if (count[s] > max)
|
|
max = count[s];
|
|
}
|
|
|
|
return (size_t)max;
|
|
}
|
|
|
|
/* FSE_count_parallel_wksp() :
|
|
* Same as FSE_count_parallel(), but using an externally provided scratch buffer.
|
|
* `workSpace` size must be a minimum of `1024 * sizeof(unsigned)`` */
|
|
static size_t FSE_count_parallel_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned checkMax,
|
|
unsigned *const workSpace)
|
|
{
|
|
const BYTE *ip = (const BYTE *)source;
|
|
const BYTE *const iend = ip + sourceSize;
|
|
unsigned maxSymbolValue = *maxSymbolValuePtr;
|
|
unsigned max = 0;
|
|
U32 *const Counting1 = workSpace;
|
|
U32 *const Counting2 = Counting1 + 256;
|
|
U32 *const Counting3 = Counting2 + 256;
|
|
U32 *const Counting4 = Counting3 + 256;
|
|
|
|
memset(Counting1, 0, 4 * 256 * sizeof(unsigned));
|
|
|
|
/* safety checks */
|
|
if (!sourceSize) {
|
|
memset(count, 0, maxSymbolValue + 1);
|
|
*maxSymbolValuePtr = 0;
|
|
return 0;
|
|
}
|
|
if (!maxSymbolValue)
|
|
maxSymbolValue = 255; /* 0 == default */
|
|
|
|
/* by stripes of 16 bytes */
|
|
{
|
|
U32 cached = ZSTD_read32(ip);
|
|
ip += 4;
|
|
while (ip < iend - 15) {
|
|
U32 c = cached;
|
|
cached = ZSTD_read32(ip);
|
|
ip += 4;
|
|
Counting1[(BYTE)c]++;
|
|
Counting2[(BYTE)(c >> 8)]++;
|
|
Counting3[(BYTE)(c >> 16)]++;
|
|
Counting4[c >> 24]++;
|
|
c = cached;
|
|
cached = ZSTD_read32(ip);
|
|
ip += 4;
|
|
Counting1[(BYTE)c]++;
|
|
Counting2[(BYTE)(c >> 8)]++;
|
|
Counting3[(BYTE)(c >> 16)]++;
|
|
Counting4[c >> 24]++;
|
|
c = cached;
|
|
cached = ZSTD_read32(ip);
|
|
ip += 4;
|
|
Counting1[(BYTE)c]++;
|
|
Counting2[(BYTE)(c >> 8)]++;
|
|
Counting3[(BYTE)(c >> 16)]++;
|
|
Counting4[c >> 24]++;
|
|
c = cached;
|
|
cached = ZSTD_read32(ip);
|
|
ip += 4;
|
|
Counting1[(BYTE)c]++;
|
|
Counting2[(BYTE)(c >> 8)]++;
|
|
Counting3[(BYTE)(c >> 16)]++;
|
|
Counting4[c >> 24]++;
|
|
}
|
|
ip -= 4;
|
|
}
|
|
|
|
/* finish last symbols */
|
|
while (ip < iend)
|
|
Counting1[*ip++]++;
|
|
|
|
if (checkMax) { /* verify stats will fit into destination table */
|
|
U32 s;
|
|
for (s = 255; s > maxSymbolValue; s--) {
|
|
Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
|
|
if (Counting1[s])
|
|
return ERROR(maxSymbolValue_tooSmall);
|
|
}
|
|
}
|
|
|
|
{
|
|
U32 s;
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
|
|
if (count[s] > max)
|
|
max = count[s];
|
|
}
|
|
}
|
|
|
|
while (!count[maxSymbolValue])
|
|
maxSymbolValue--;
|
|
*maxSymbolValuePtr = maxSymbolValue;
|
|
return (size_t)max;
|
|
}
|
|
|
|
/* FSE_countFast_wksp() :
|
|
* Same as FSE_countFast(), but using an externally provided scratch buffer.
|
|
* `workSpace` size must be table of >= `1024` unsigned */
|
|
size_t FSE_countFast_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned *workSpace)
|
|
{
|
|
if (sourceSize < 1500)
|
|
return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize);
|
|
return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 0, workSpace);
|
|
}
|
|
|
|
/* FSE_count_wksp() :
|
|
* Same as FSE_count(), but using an externally provided scratch buffer.
|
|
* `workSpace` size must be table of >= `1024` unsigned */
|
|
size_t FSE_count_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, unsigned *workSpace)
|
|
{
|
|
if (*maxSymbolValuePtr < 255)
|
|
return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 1, workSpace);
|
|
*maxSymbolValuePtr = 255;
|
|
return FSE_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace);
|
|
}
|
|
|
|
/*-**************************************************************
|
|
* FSE Compression Code
|
|
****************************************************************/
|
|
/*! FSE_sizeof_CTable() :
|
|
FSE_CTable is a variable size structure which contains :
|
|
`U16 tableLog;`
|
|
`U16 maxSymbolValue;`
|
|
`U16 nextStateNumber[1 << tableLog];` // This size is variable
|
|
`FSE_symbolCompressionTransform symbolTT[maxSymbolValue+1];` // This size is variable
|
|
Allocation is manual (C standard does not support variable-size structures).
|
|
*/
|
|
size_t FSE_sizeof_CTable(unsigned maxSymbolValue, unsigned tableLog)
|
|
{
|
|
if (tableLog > FSE_MAX_TABLELOG)
|
|
return ERROR(tableLog_tooLarge);
|
|
return FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue) * sizeof(U32);
|
|
}
|
|
|
|
/* provides the minimum logSize to safely represent a distribution */
|
|
static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
|
|
{
|
|
U32 minBitsSrc = BIT_highbit32((U32)(srcSize - 1)) + 1;
|
|
U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
|
|
U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
|
|
return minBits;
|
|
}
|
|
|
|
unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
|
|
{
|
|
U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
|
|
U32 tableLog = maxTableLog;
|
|
U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
|
|
if (tableLog == 0)
|
|
tableLog = FSE_DEFAULT_TABLELOG;
|
|
if (maxBitsSrc < tableLog)
|
|
tableLog = maxBitsSrc; /* Accuracy can be reduced */
|
|
if (minBits > tableLog)
|
|
tableLog = minBits; /* Need a minimum to safely represent all symbol values */
|
|
if (tableLog < FSE_MIN_TABLELOG)
|
|
tableLog = FSE_MIN_TABLELOG;
|
|
if (tableLog > FSE_MAX_TABLELOG)
|
|
tableLog = FSE_MAX_TABLELOG;
|
|
return tableLog;
|
|
}
|
|
|
|
unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
|
|
{
|
|
return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
|
|
}
|
|
|
|
/* Secondary normalization method.
|
|
To be used when primary method fails. */
|
|
|
|
static size_t FSE_normalizeM2(short *norm, U32 tableLog, const unsigned *count, size_t total, U32 maxSymbolValue)
|
|
{
|
|
short const NOT_YET_ASSIGNED = -2;
|
|
U32 s;
|
|
U32 distributed = 0;
|
|
U32 ToDistribute;
|
|
|
|
/* Init */
|
|
U32 const lowThreshold = (U32)(total >> tableLog);
|
|
U32 lowOne = (U32)((total * 3) >> (tableLog + 1));
|
|
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
if (count[s] == 0) {
|
|
norm[s] = 0;
|
|
continue;
|
|
}
|
|
if (count[s] <= lowThreshold) {
|
|
norm[s] = -1;
|
|
distributed++;
|
|
total -= count[s];
|
|
continue;
|
|
}
|
|
if (count[s] <= lowOne) {
|
|
norm[s] = 1;
|
|
distributed++;
|
|
total -= count[s];
|
|
continue;
|
|
}
|
|
|
|
norm[s] = NOT_YET_ASSIGNED;
|
|
}
|
|
ToDistribute = (1 << tableLog) - distributed;
|
|
|
|
if ((total / ToDistribute) > lowOne) {
|
|
/* risk of rounding to zero */
|
|
lowOne = (U32)((total * 3) / (ToDistribute * 2));
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {
|
|
norm[s] = 1;
|
|
distributed++;
|
|
total -= count[s];
|
|
continue;
|
|
}
|
|
}
|
|
ToDistribute = (1 << tableLog) - distributed;
|
|
}
|
|
|
|
if (distributed == maxSymbolValue + 1) {
|
|
/* all values are pretty poor;
|
|
probably incompressible data (should have already been detected);
|
|
find max, then give all remaining points to max */
|
|
U32 maxV = 0, maxC = 0;
|
|
for (s = 0; s <= maxSymbolValue; s++)
|
|
if (count[s] > maxC)
|
|
maxV = s, maxC = count[s];
|
|
norm[maxV] += (short)ToDistribute;
|
|
return 0;
|
|
}
|
|
|
|
if (total == 0) {
|
|
/* all of the symbols were low enough for the lowOne or lowThreshold */
|
|
for (s = 0; ToDistribute > 0; s = (s + 1) % (maxSymbolValue + 1))
|
|
if (norm[s] > 0)
|
|
ToDistribute--, norm[s]++;
|
|
return 0;
|
|
}
|
|
|
|
{
|
|
U64 const vStepLog = 62 - tableLog;
|
|
U64 const mid = (1ULL << (vStepLog - 1)) - 1;
|
|
U64 const rStep = div_u64((((U64)1 << vStepLog) * ToDistribute) + mid, (U32)total); /* scale on remaining */
|
|
U64 tmpTotal = mid;
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
if (norm[s] == NOT_YET_ASSIGNED) {
|
|
U64 const end = tmpTotal + (count[s] * rStep);
|
|
U32 const sStart = (U32)(tmpTotal >> vStepLog);
|
|
U32 const sEnd = (U32)(end >> vStepLog);
|
|
U32 const weight = sEnd - sStart;
|
|
if (weight < 1)
|
|
return ERROR(GENERIC);
|
|
norm[s] = (short)weight;
|
|
tmpTotal = end;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t FSE_normalizeCount(short *normalizedCounter, unsigned tableLog, const unsigned *count, size_t total, unsigned maxSymbolValue)
|
|
{
|
|
/* Sanity checks */
|
|
if (tableLog == 0)
|
|
tableLog = FSE_DEFAULT_TABLELOG;
|
|
if (tableLog < FSE_MIN_TABLELOG)
|
|
return ERROR(GENERIC); /* Unsupported size */
|
|
if (tableLog > FSE_MAX_TABLELOG)
|
|
return ERROR(tableLog_tooLarge); /* Unsupported size */
|
|
if (tableLog < FSE_minTableLog(total, maxSymbolValue))
|
|
return ERROR(GENERIC); /* Too small tableLog, compression potentially impossible */
|
|
|
|
{
|
|
U32 const rtbTable[] = {0, 473195, 504333, 520860, 550000, 700000, 750000, 830000};
|
|
U64 const scale = 62 - tableLog;
|
|
U64 const step = div_u64((U64)1 << 62, (U32)total); /* <== here, one division ! */
|
|
U64 const vStep = 1ULL << (scale - 20);
|
|
int stillToDistribute = 1 << tableLog;
|
|
unsigned s;
|
|
unsigned largest = 0;
|
|
short largestP = 0;
|
|
U32 lowThreshold = (U32)(total >> tableLog);
|
|
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
if (count[s] == total)
|
|
return 0; /* rle special case */
|
|
if (count[s] == 0) {
|
|
normalizedCounter[s] = 0;
|
|
continue;
|
|
}
|
|
if (count[s] <= lowThreshold) {
|
|
normalizedCounter[s] = -1;
|
|
stillToDistribute--;
|
|
} else {
|
|
short proba = (short)((count[s] * step) >> scale);
|
|
if (proba < 8) {
|
|
U64 restToBeat = vStep * rtbTable[proba];
|
|
proba += (count[s] * step) - ((U64)proba << scale) > restToBeat;
|
|
}
|
|
if (proba > largestP)
|
|
largestP = proba, largest = s;
|
|
normalizedCounter[s] = proba;
|
|
stillToDistribute -= proba;
|
|
}
|
|
}
|
|
if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
|
|
/* corner case, need another normalization method */
|
|
size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue);
|
|
if (FSE_isError(errorCode))
|
|
return errorCode;
|
|
} else
|
|
normalizedCounter[largest] += (short)stillToDistribute;
|
|
}
|
|
|
|
return tableLog;
|
|
}
|
|
|
|
/* fake FSE_CTable, for raw (uncompressed) input */
|
|
size_t FSE_buildCTable_raw(FSE_CTable *ct, unsigned nbBits)
|
|
{
|
|
const unsigned tableSize = 1 << nbBits;
|
|
const unsigned tableMask = tableSize - 1;
|
|
const unsigned maxSymbolValue = tableMask;
|
|
void *const ptr = ct;
|
|
U16 *const tableU16 = ((U16 *)ptr) + 2;
|
|
void *const FSCT = ((U32 *)ptr) + 1 /* header */ + (tableSize >> 1); /* assumption : tableLog >= 1 */
|
|
FSE_symbolCompressionTransform *const symbolTT = (FSE_symbolCompressionTransform *)(FSCT);
|
|
unsigned s;
|
|
|
|
/* Sanity checks */
|
|
if (nbBits < 1)
|
|
return ERROR(GENERIC); /* min size */
|
|
|
|
/* header */
|
|
tableU16[-2] = (U16)nbBits;
|
|
tableU16[-1] = (U16)maxSymbolValue;
|
|
|
|
/* Build table */
|
|
for (s = 0; s < tableSize; s++)
|
|
tableU16[s] = (U16)(tableSize + s);
|
|
|
|
/* Build Symbol Transformation Table */
|
|
{
|
|
const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
|
|
for (s = 0; s <= maxSymbolValue; s++) {
|
|
symbolTT[s].deltaNbBits = deltaNbBits;
|
|
symbolTT[s].deltaFindState = s - 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* fake FSE_CTable, for rle input (always same symbol) */
|
|
size_t FSE_buildCTable_rle(FSE_CTable *ct, BYTE symbolValue)
|
|
{
|
|
void *ptr = ct;
|
|
U16 *tableU16 = ((U16 *)ptr) + 2;
|
|
void *FSCTptr = (U32 *)ptr + 2;
|
|
FSE_symbolCompressionTransform *symbolTT = (FSE_symbolCompressionTransform *)FSCTptr;
|
|
|
|
/* header */
|
|
tableU16[-2] = (U16)0;
|
|
tableU16[-1] = (U16)symbolValue;
|
|
|
|
/* Build table */
|
|
tableU16[0] = 0;
|
|
tableU16[1] = 0; /* just in case */
|
|
|
|
/* Build Symbol Transformation Table */
|
|
symbolTT[symbolValue].deltaNbBits = 0;
|
|
symbolTT[symbolValue].deltaFindState = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static size_t FSE_compress_usingCTable_generic(void *dst, size_t dstSize, const void *src, size_t srcSize, const FSE_CTable *ct, const unsigned fast)
|
|
{
|
|
const BYTE *const istart = (const BYTE *)src;
|
|
const BYTE *const iend = istart + srcSize;
|
|
const BYTE *ip = iend;
|
|
|
|
BIT_CStream_t bitC;
|
|
FSE_CState_t CState1, CState2;
|
|
|
|
/* init */
|
|
if (srcSize <= 2)
|
|
return 0;
|
|
{
|
|
size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
|
|
if (FSE_isError(initError))
|
|
return 0; /* not enough space available to write a bitstream */
|
|
}
|
|
|
|
#define FSE_FLUSHBITS(s) (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
|
|
|
|
if (srcSize & 1) {
|
|
FSE_initCState2(&CState1, ct, *--ip);
|
|
FSE_initCState2(&CState2, ct, *--ip);
|
|
FSE_encodeSymbol(&bitC, &CState1, *--ip);
|
|
FSE_FLUSHBITS(&bitC);
|
|
} else {
|
|
FSE_initCState2(&CState2, ct, *--ip);
|
|
FSE_initCState2(&CState1, ct, *--ip);
|
|
}
|
|
|
|
/* join to mod 4 */
|
|
srcSize -= 2;
|
|
if ((sizeof(bitC.bitContainer) * 8 > FSE_MAX_TABLELOG * 4 + 7) && (srcSize & 2)) { /* test bit 2 */
|
|
FSE_encodeSymbol(&bitC, &CState2, *--ip);
|
|
FSE_encodeSymbol(&bitC, &CState1, *--ip);
|
|
FSE_FLUSHBITS(&bitC);
|
|
}
|
|
|
|
/* 2 or 4 encoding per loop */
|
|
while (ip > istart) {
|
|
|
|
FSE_encodeSymbol(&bitC, &CState2, *--ip);
|
|
|
|
if (sizeof(bitC.bitContainer) * 8 < FSE_MAX_TABLELOG * 2 + 7) /* this test must be static */
|
|
FSE_FLUSHBITS(&bitC);
|
|
|
|
FSE_encodeSymbol(&bitC, &CState1, *--ip);
|
|
|
|
if (sizeof(bitC.bitContainer) * 8 > FSE_MAX_TABLELOG * 4 + 7) { /* this test must be static */
|
|
FSE_encodeSymbol(&bitC, &CState2, *--ip);
|
|
FSE_encodeSymbol(&bitC, &CState1, *--ip);
|
|
}
|
|
|
|
FSE_FLUSHBITS(&bitC);
|
|
}
|
|
|
|
FSE_flushCState(&bitC, &CState2);
|
|
FSE_flushCState(&bitC, &CState1);
|
|
return BIT_closeCStream(&bitC);
|
|
}
|
|
|
|
size_t FSE_compress_usingCTable(void *dst, size_t dstSize, const void *src, size_t srcSize, const FSE_CTable *ct)
|
|
{
|
|
unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));
|
|
|
|
if (fast)
|
|
return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);
|
|
else
|
|
return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
|
|
}
|
|
|
|
size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
|