2015-01-24 00:58:16 +00:00
/* ******************************************************************
2016-04-22 10:43:18 +00:00
FSE : Finite State Entropy encoder
2018-06-13 23:49:31 +00:00
Copyright ( C ) 2013 - present , Yann Collet .
2015-01-24 00:58:16 +00:00
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 .
You can contact the author at :
- FSE source repository : https : //github.com/Cyan4973/FiniteStateEntropy
- Public forum : https : //groups.google.com/forum/#!forum/lz4c
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2016-01-06 00:58:37 +00:00
/* **************************************************************
2015-01-24 00:58:16 +00:00
* Includes
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include <stdlib.h> /* malloc, free, qsort */
# include <string.h> /* memcpy, memset */
2017-08-15 00:20:50 +00:00
# include "compiler.h"
2018-06-13 23:49:31 +00:00
# include "mem.h" /* U32, U16, etc. */
# include "debug.h" /* assert, DEBUGLOG */
# include "hist.h" /* HIST_count_wksp */
# include "bitstream.h"
2016-06-04 22:58:01 +00:00
# define FSE_STATIC_LINKING_ONLY
# include "fse.h"
2017-08-15 18:23:28 +00:00
# include "error_private.h"
2015-01-24 00:58:16 +00:00
2016-01-06 00:58:37 +00:00
/* **************************************************************
2015-01-24 00:58:16 +00:00
* Error Management
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2017-08-15 18:23:28 +00:00
# define FSE_isError ERR_isError
2015-01-24 00:58:16 +00:00
2016-01-06 00:58:37 +00:00
/* **************************************************************
2015-07-25 23:23:57 +00:00
* Templates
2015-01-24 00:58:16 +00:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2015-07-25 23:23:57 +00:00
/*
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
2015-01-24 00:58:16 +00:00
2015-07-25 23:23:57 +00:00
/* 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)
2015-06-18 15:43:16 +00:00
2015-07-25 23:23:57 +00:00
/* Function templates */
2016-11-30 23:52:20 +00:00
/* 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
*/
2018-08-14 19:56:21 +00:00
size_t FSE_buildCTable_wksp ( FSE_CTable * ct ,
const short * normalizedCounter , unsigned maxSymbolValue , unsigned tableLog ,
void * workSpace , size_t wkspSize )
2015-01-24 00:58:16 +00:00
{
2016-03-20 23:39:19 +00:00
U32 const tableSize = 1 < < tableLog ;
U32 const tableMask = tableSize - 1 ;
2016-01-06 00:58:37 +00:00
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 ) ;
2016-04-22 10:43:18 +00:00
U32 const step = FSE_TABLESTEP ( tableSize ) ;
2016-03-20 23:39:19 +00:00
U32 cumul [ FSE_MAX_SYMBOL_VALUE + 2 ] ;
2016-04-22 10:43:18 +00:00
2016-11-30 23:52:20 +00:00
FSE_FUNCTION_TYPE * const tableSymbol = ( FSE_FUNCTION_TYPE * ) workSpace ;
2015-07-25 23:23:57 +00:00
U32 highThreshold = tableSize - 1 ;
2015-01-24 00:58:16 +00:00
2016-03-20 23:39:19 +00:00
/* CTable header */
2016-12-01 02:10:38 +00:00
if ( ( ( size_t ) 1 < < tableLog ) * sizeof ( FSE_FUNCTION_TYPE ) > wkspSize ) return ERROR ( tableLog_tooLarge ) ;
2015-07-25 23:23:57 +00:00
tableU16 [ - 2 ] = ( U16 ) tableLog ;
tableU16 [ - 1 ] = ( U16 ) maxSymbolValue ;
2018-08-14 19:56:21 +00:00
assert ( tableLog < 16 ) ; /* required for threshold strategy to work */
2015-07-25 23:23:57 +00:00
/* For explanations on how to distribute symbol values over the table :
2018-08-14 19:56:21 +00:00
* http : //fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
# ifdef __clang_analyzer__
memset ( tableSymbol , 0 , sizeof ( * tableSymbol ) * tableSize ) ; /* useless initialization, just to keep scan-build happy */
# endif
2015-07-25 23:23:57 +00:00
/* symbol start positions */
2016-03-20 23:39:19 +00:00
{ 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 ;
}
2015-07-25 23:23:57 +00:00
/* Spread symbols */
2016-03-20 23:39:19 +00:00
{ U32 position = 0 ;
U32 symbol ;
for ( symbol = 0 ; symbol < = maxSymbolValue ; symbol + + ) {
int nbOccurences ;
2018-08-14 19:56:21 +00:00
int const freq = normalizedCounter [ symbol ] ;
for ( nbOccurences = 0 ; nbOccurences < freq ; nbOccurences + + ) {
2016-03-20 23:39:19 +00:00
tableSymbol [ position ] = ( FSE_FUNCTION_TYPE ) symbol ;
position = ( position + step ) & tableMask ;
2018-08-14 19:56:21 +00:00
while ( position > highThreshold )
position = ( position + step ) & tableMask ; /* Low proba area */
2016-03-20 23:39:19 +00:00
} }
2016-04-22 10:43:18 +00:00
2018-08-14 19:56:21 +00:00
assert ( position = = 0 ) ; /* Must have initialized all positions */
2016-03-20 23:39:19 +00:00
}
2015-07-25 23:23:57 +00:00
/* Build table */
2016-05-20 10:34:40 +00:00
{ U32 u ; for ( u = 0 ; u < tableSize ; u + + ) {
2016-03-20 23:39:19 +00:00
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 */
2016-05-20 10:34:40 +00:00
} }
2015-07-25 23:23:57 +00:00
/* Build Symbol Transformation Table */
2016-03-20 23:39:19 +00:00
{ unsigned total = 0 ;
2015-07-25 23:23:57 +00:00
unsigned s ;
2016-01-28 02:24:53 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + ) {
2015-07-25 23:23:57 +00:00
switch ( normalizedCounter [ s ] )
{
2018-05-11 00:59:12 +00:00
case 0 :
/* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
2018-05-24 20:59:11 +00:00
symbolTT [ s ] . deltaNbBits = ( ( tableLog + 1 ) < < 16 ) - ( 1 < < tableLog ) ;
2018-05-11 00:59:12 +00:00
break ;
2016-04-22 10:43:18 +00:00
2015-07-25 23:23:57 +00:00
case - 1 :
2015-08-02 00:19:09 +00:00
case 1 :
2016-01-30 23:58:06 +00:00
symbolTT [ s ] . deltaNbBits = ( tableLog < < 16 ) - ( 1 < < tableLog ) ;
2015-07-25 23:23:57 +00:00
symbolTT [ s ] . deltaFindState = total - 1 ;
total + + ;
break ;
default :
2015-08-02 00:19:09 +00:00
{
2016-03-20 23:39:19 +00:00
U32 const maxBitsOut = tableLog - BIT_highbit32 ( normalizedCounter [ s ] - 1 ) ;
U32 const minStatePlus = normalizedCounter [ s ] < < maxBitsOut ;
2015-08-02 00:19:09 +00:00
symbolTT [ s ] . deltaNbBits = ( maxBitsOut < < 16 ) - minStatePlus ;
symbolTT [ s ] . deltaFindState = total - normalizedCounter [ s ] ;
total + = normalizedCounter [ s ] ;
2016-01-30 23:58:06 +00:00
} } } }
2015-07-25 23:23:57 +00:00
2018-05-09 19:00:12 +00:00
#if 0 /* debug : symbol costs */
2018-05-09 22:46:11 +00:00
DEBUGLOG ( 5 , " \n --- table statistics : " ) ;
2018-05-09 19:00:12 +00:00
{ U32 symbol ;
for ( symbol = 0 ; symbol < = maxSymbolValue ; symbol + + ) {
2018-05-09 22:46:11 +00:00
DEBUGLOG ( 5 , " %3u: w=%3i, maxBits=%u, fracBits=%.2f " ,
2018-05-09 19:00:12 +00:00
symbol , normalizedCounter [ symbol ] ,
FSE_getMaxNbBits ( symbolTT , symbol ) ,
( double ) FSE_bitCost ( symbolTT , tableLog , symbol , 8 ) / 256 ) ;
}
}
# endif
2015-07-25 23:23:57 +00:00
return 0 ;
}
2016-11-30 23:52:20 +00:00
size_t FSE_buildCTable ( FSE_CTable * ct , const short * normalizedCounter , unsigned maxSymbolValue , unsigned tableLog )
{
FSE_FUNCTION_TYPE tableSymbol [ FSE_MAX_TABLESIZE ] ; /* memset() is not necessary, even if static analyzer complain about it */
return FSE_buildCTable_wksp ( ct , normalizedCounter , maxSymbolValue , tableLog , tableSymbol , sizeof ( tableSymbol ) ) ;
}
2015-07-25 23:23:57 +00:00
2015-10-18 21:18:32 +00:00
# ifndef FSE_COMMONDEFS_ONLY
2015-07-25 23:23:57 +00:00
2018-06-13 23:49:31 +00:00
2016-01-28 02:24:53 +00:00
/*-**************************************************************
2018-06-13 23:49:31 +00:00
* FSE NCount encoding
2015-07-25 23:23:57 +00:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
size_t FSE_NCountWriteBound ( unsigned maxSymbolValue , unsigned tableLog )
{
2016-11-30 23:52:20 +00:00
size_t const maxHeaderSize = ( ( ( maxSymbolValue + 1 ) * tableLog ) > > 3 ) + 3 ;
2015-08-19 22:53:56 +00:00
return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND ; /* maxSymbolValue==0 ? use default */
2015-07-25 23:23:57 +00:00
}
2018-08-14 19:56:21 +00:00
static size_t
FSE_writeNCount_generic ( void * header , size_t headerBufferSize ,
const short * normalizedCounter , unsigned maxSymbolValue , unsigned tableLog ,
unsigned writeIsSafe )
2015-07-25 23:23:57 +00:00
{
BYTE * const ostart = ( BYTE * ) header ;
BYTE * out = ostart ;
BYTE * const oend = ostart + headerBufferSize ;
int nbBits ;
const int tableSize = 1 < < tableLog ;
int remaining ;
int threshold ;
2018-08-14 19:56:21 +00:00
U32 bitStream = 0 ;
int bitCount = 0 ;
unsigned symbol = 0 ;
unsigned const alphabetSize = maxSymbolValue + 1 ;
int previousIs0 = 0 ;
2015-07-25 23:23:57 +00:00
/* Table Size */
bitStream + = ( tableLog - FSE_MIN_TABLELOG ) < < bitCount ;
bitCount + = 4 ;
/* Init */
remaining = tableSize + 1 ; /* +1 for extra accuracy */
threshold = tableSize ;
nbBits = tableLog + 1 ;
2018-08-14 19:56:21 +00:00
while ( ( symbol < alphabetSize ) & & ( remaining > 1 ) ) { /* stops at 1 */
if ( previousIs0 ) {
unsigned start = symbol ;
while ( ( symbol < alphabetSize ) & & ! normalizedCounter [ symbol ] ) symbol + + ;
2018-08-16 21:40:47 +00:00
if ( symbol = = alphabetSize ) break ; /* incorrect distribution */
2018-08-14 19:56:21 +00:00
while ( symbol > = start + 24 ) {
2015-07-25 23:23:57 +00:00
start + = 24 ;
bitStream + = 0xFFFFU < < bitCount ;
2018-08-16 21:40:47 +00:00
if ( ( ! writeIsSafe ) & & ( out > oend - 2 ) )
return ERROR ( dstSize_tooSmall ) ; /* Buffer overflow */
2015-07-25 23:23:57 +00:00
out [ 0 ] = ( BYTE ) bitStream ;
out [ 1 ] = ( BYTE ) ( bitStream > > 8 ) ;
out + = 2 ;
bitStream > > = 16 ;
}
2018-08-14 19:56:21 +00:00
while ( symbol > = start + 3 ) {
2015-07-25 23:23:57 +00:00
start + = 3 ;
bitStream + = 3 < < bitCount ;
bitCount + = 2 ;
}
2018-08-14 19:56:21 +00:00
bitStream + = ( symbol - start ) < < bitCount ;
2015-07-25 23:23:57 +00:00
bitCount + = 2 ;
2016-01-27 23:18:06 +00:00
if ( bitCount > 16 ) {
2018-08-16 21:40:47 +00:00
if ( ( ! writeIsSafe ) & & ( out > oend - 2 ) )
return ERROR ( dstSize_tooSmall ) ; /* Buffer overflow */
2015-07-25 23:23:57 +00:00
out [ 0 ] = ( BYTE ) bitStream ;
out [ 1 ] = ( BYTE ) ( bitStream > > 8 ) ;
out + = 2 ;
bitStream > > = 16 ;
bitCount - = 16 ;
2016-01-27 23:18:06 +00:00
} }
2018-08-14 19:56:21 +00:00
{ int count = normalizedCounter [ symbol + + ] ;
int const max = ( 2 * threshold - 1 ) - remaining ;
2017-02-15 20:00:03 +00:00
remaining - = count < 0 ? - count : count ;
2015-07-25 23:23:57 +00:00
count + + ; /* +1 for extra accuracy */
2018-08-16 21:40:47 +00:00
if ( count > = threshold )
count + = max ; /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
2015-07-25 23:23:57 +00:00
bitStream + = count < < bitCount ;
bitCount + = nbBits ;
bitCount - = ( count < max ) ;
2018-08-14 19:56:21 +00:00
previousIs0 = ( count = = 1 ) ;
2017-02-15 20:00:03 +00:00
if ( remaining < 1 ) return ERROR ( GENERIC ) ;
2018-02-22 23:44:26 +00:00
while ( remaining < threshold ) { nbBits - - ; threshold > > = 1 ; }
2015-07-25 23:23:57 +00:00
}
2016-01-27 23:18:06 +00:00
if ( bitCount > 16 ) {
2018-08-16 21:40:47 +00:00
if ( ( ! writeIsSafe ) & & ( out > oend - 2 ) )
return ERROR ( dstSize_tooSmall ) ; /* Buffer overflow */
2015-07-25 23:23:57 +00:00
out [ 0 ] = ( BYTE ) bitStream ;
out [ 1 ] = ( BYTE ) ( bitStream > > 8 ) ;
out + = 2 ;
bitStream > > = 16 ;
bitCount - = 16 ;
2016-01-30 23:58:06 +00:00
} }
2015-07-25 23:23:57 +00:00
2018-08-16 21:40:47 +00:00
if ( remaining ! = 1 )
return ERROR ( GENERIC ) ; /* incorrect normalized distribution */
2018-08-14 19:56:21 +00:00
assert ( symbol < = alphabetSize ) ;
2015-07-25 23:23:57 +00:00
/* flush remaining bitStream */
2018-08-16 21:40:47 +00:00
if ( ( ! writeIsSafe ) & & ( out > oend - 2 ) )
return ERROR ( dstSize_tooSmall ) ; /* Buffer overflow */
2015-07-25 23:23:57 +00:00
out [ 0 ] = ( BYTE ) bitStream ;
out [ 1 ] = ( BYTE ) ( bitStream > > 8 ) ;
out + = ( bitCount + 7 ) / 8 ;
return ( out - ostart ) ;
}
2018-08-16 21:40:47 +00:00
size_t FSE_writeNCount ( void * buffer , size_t bufferSize ,
const short * normalizedCounter , unsigned maxSymbolValue , unsigned tableLog )
2015-07-25 23:23:57 +00:00
{
2017-03-24 00:59:50 +00:00
if ( tableLog > FSE_MAX_TABLELOG ) return ERROR ( tableLog_tooLarge ) ; /* Unsupported */
2015-10-18 21:18:32 +00:00
if ( tableLog < FSE_MIN_TABLELOG ) return ERROR ( GENERIC ) ; /* Unsupported */
2015-07-25 23:23:57 +00:00
2015-08-21 01:44:20 +00:00
if ( bufferSize < FSE_NCountWriteBound ( maxSymbolValue , tableLog ) )
return FSE_writeNCount_generic ( buffer , bufferSize , normalizedCounter , maxSymbolValue , tableLog , 0 ) ;
2015-07-25 23:23:57 +00:00
2018-08-14 19:56:21 +00:00
return FSE_writeNCount_generic ( buffer , bufferSize , normalizedCounter , maxSymbolValue , tableLog , 1 /* write in buffer is safe */ ) ;
2015-07-25 23:23:57 +00:00
}
2016-01-28 02:24:53 +00:00
/*-**************************************************************
2015-01-24 00:58:16 +00:00
* FSE Compression Code
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2016-03-04 18:26:59 +00:00
/*! 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
2016-03-21 12:24:16 +00:00
Allocation is manual ( C standard does not support variable - size structures ) .
2015-01-24 00:58:16 +00:00
*/
size_t FSE_sizeof_CTable ( unsigned maxSymbolValue , unsigned tableLog )
{
2016-12-01 00:46:13 +00:00
if ( tableLog > FSE_MAX_TABLELOG ) return ERROR ( tableLog_tooLarge ) ;
return FSE_CTABLE_SIZE_U32 ( tableLog , maxSymbolValue ) * sizeof ( U32 ) ;
2015-01-24 00:58:16 +00:00
}
2015-07-04 23:56:41 +00:00
FSE_CTable * FSE_createCTable ( unsigned maxSymbolValue , unsigned tableLog )
2015-01-24 00:58:16 +00:00
{
size_t size ;
if ( tableLog > FSE_TABLELOG_ABSOLUTE_MAX ) tableLog = FSE_TABLELOG_ABSOLUTE_MAX ;
size = FSE_CTABLE_SIZE_U32 ( tableLog , maxSymbolValue ) * sizeof ( U32 ) ;
2015-07-04 23:56:41 +00:00
return ( FSE_CTable * ) malloc ( size ) ;
2015-01-24 00:58:16 +00:00
}
2016-05-20 12:36:36 +00:00
void FSE_freeCTable ( FSE_CTable * ct ) { free ( ct ) ; }
2015-01-24 00:58:16 +00:00
2015-08-21 02:59:31 +00:00
/* provides the minimum logSize to safely represent a distribution */
static unsigned FSE_minTableLog ( size_t srcSize , unsigned maxSymbolValue )
2015-01-24 00:58:16 +00:00
{
2018-08-02 18:12:17 +00:00
U32 minBitsSrc = BIT_highbit32 ( ( U32 ) ( srcSize ) ) + 1 ;
2017-03-30 01:51:58 +00:00
U32 minBitsSymbols = BIT_highbit32 ( maxSymbolValue ) + 2 ;
U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols ;
2017-09-16 02:00:39 +00:00
assert ( srcSize > 1 ) ; /* Not supported, RLE should be used instead */
2017-03-30 01:51:58 +00:00
return minBits ;
2015-08-21 02:59:31 +00:00
}
2016-05-20 12:36:36 +00:00
unsigned FSE_optimalTableLog_internal ( unsigned maxTableLog , size_t srcSize , unsigned maxSymbolValue , unsigned minus )
2015-08-21 02:59:31 +00:00
{
2017-03-30 01:51:58 +00:00
U32 maxBitsSrc = BIT_highbit32 ( ( U32 ) ( srcSize - 1 ) ) - minus ;
2015-08-21 02:59:31 +00:00
U32 tableLog = maxTableLog ;
2017-03-30 01:51:58 +00:00
U32 minBits = FSE_minTableLog ( srcSize , maxSymbolValue ) ;
2017-09-16 02:00:39 +00:00
assert ( srcSize > 1 ) ; /* Not supported, RLE should be used instead */
2015-01-24 00:58:16 +00:00
if ( tableLog = = 0 ) tableLog = FSE_DEFAULT_TABLELOG ;
2017-03-30 01:51:58 +00:00
if ( maxBitsSrc < tableLog ) tableLog = maxBitsSrc ; /* Accuracy can be reduced */
if ( minBits > tableLog ) tableLog = minBits ; /* Need a minimum to safely represent all symbol values */
2015-01-24 00:58:16 +00:00
if ( tableLog < FSE_MIN_TABLELOG ) tableLog = FSE_MIN_TABLELOG ;
if ( tableLog > FSE_MAX_TABLELOG ) tableLog = FSE_MAX_TABLELOG ;
return tableLog ;
}
2016-05-20 12:36:36 +00:00
unsigned FSE_optimalTableLog ( unsigned maxTableLog , size_t srcSize , unsigned maxSymbolValue )
{
return FSE_optimalTableLog_internal ( maxTableLog , srcSize , maxSymbolValue , 2 ) ;
}
2015-01-24 00:58:16 +00:00
2015-02-24 08:05:58 +00:00
/* 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 )
2015-02-21 02:31:59 +00:00
{
2017-02-22 21:52:48 +00:00
short const NOT_YET_ASSIGNED = - 2 ;
2015-02-21 02:31:59 +00:00
U32 s ;
U32 distributed = 0 ;
U32 ToDistribute ;
/* Init */
2016-11-30 23:52:20 +00:00
U32 const lowThreshold = ( U32 ) ( total > > tableLog ) ;
2015-02-21 02:31:59 +00:00
U32 lowOne = ( U32 ) ( ( total * 3 ) > > ( tableLog + 1 ) ) ;
2016-01-27 23:18:06 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + ) {
if ( count [ s ] = = 0 ) {
2015-02-21 02:31:59 +00:00
norm [ s ] = 0 ;
continue ;
}
2016-01-27 23:18:06 +00:00
if ( count [ s ] < = lowThreshold ) {
2015-02-21 02:31:59 +00:00
norm [ s ] = - 1 ;
distributed + + ;
total - = count [ s ] ;
continue ;
}
2016-01-27 23:18:06 +00:00
if ( count [ s ] < = lowOne ) {
2015-02-21 02:31:59 +00:00
norm [ s ] = 1 ;
distributed + + ;
total - = count [ s ] ;
continue ;
}
2017-02-22 21:52:48 +00:00
norm [ s ] = NOT_YET_ASSIGNED ;
2015-02-21 02:31:59 +00:00
}
ToDistribute = ( 1 < < tableLog ) - distributed ;
2018-07-28 00:30:03 +00:00
if ( ToDistribute = = 0 )
return 0 ;
2016-01-27 23:18:06 +00:00
if ( ( total / ToDistribute ) > lowOne ) {
2015-02-21 02:31:59 +00:00
/* risk of rounding to zero */
lowOne = ( U32 ) ( ( total * 3 ) / ( ToDistribute * 2 ) ) ;
2016-01-27 23:18:06 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + ) {
2017-02-22 21:52:48 +00:00
if ( ( norm [ s ] = = NOT_YET_ASSIGNED ) & & ( count [ s ] < = lowOne ) ) {
2015-02-21 02:31:59 +00:00
norm [ s ] = 1 ;
distributed + + ;
total - = count [ s ] ;
continue ;
2016-01-27 23:18:06 +00:00
} }
2015-02-21 02:31:59 +00:00
ToDistribute = ( 1 < < tableLog ) - distributed ;
}
2016-01-27 23:18:06 +00:00
if ( distributed = = maxSymbolValue + 1 ) {
2015-02-24 08:05:58 +00:00
/* all values are pretty poor;
probably incompressible data ( should have already been detected ) ;
find max , then give all remaining points to max */
2016-03-21 12:24:16 +00:00
U32 maxV = 0 , maxC = 0 ;
2015-02-21 02:31:59 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + )
2018-02-22 23:44:26 +00:00
if ( count [ s ] > maxC ) { maxV = s ; maxC = count [ s ] ; }
2015-07-04 23:56:41 +00:00
norm [ maxV ] + = ( short ) ToDistribute ;
2015-02-21 02:31:59 +00:00
return 0 ;
}
2017-02-22 21:52:48 +00:00
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 ) )
2018-02-22 23:44:26 +00:00
if ( norm [ s ] > 0 ) { ToDistribute - - ; norm [ s ] + + ; }
2017-02-22 21:52:48 +00:00
return 0 ;
}
2016-11-30 23:52:20 +00:00
{ U64 const vStepLog = 62 - tableLog ;
2015-02-21 02:31:59 +00:00
U64 const mid = ( 1ULL < < ( vStepLog - 1 ) ) - 1 ;
U64 const rStep = ( ( ( ( U64 ) 1 < < vStepLog ) * ToDistribute ) + mid ) / total ; /* scale on remaining */
U64 tmpTotal = mid ;
2016-01-27 23:18:06 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + ) {
2017-02-22 21:52:48 +00:00
if ( norm [ s ] = = NOT_YET_ASSIGNED ) {
2016-11-30 23:52:20 +00:00
U64 const end = tmpTotal + ( count [ s ] * rStep ) ;
U32 const sStart = ( U32 ) ( tmpTotal > > vStepLog ) ;
U32 const sEnd = ( U32 ) ( end > > vStepLog ) ;
U32 const weight = sEnd - sStart ;
2015-02-21 02:31:59 +00:00
if ( weight < 1 )
2015-10-18 21:18:32 +00:00
return ERROR ( GENERIC ) ;
2015-06-18 15:43:16 +00:00
norm [ s ] = ( short ) weight ;
2015-02-21 02:31:59 +00:00
tmpTotal = end ;
2016-01-27 23:18:06 +00:00
} } }
2015-02-21 02:31:59 +00:00
return 0 ;
}
2015-01-24 00:58:16 +00:00
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 ;
2015-10-18 21:18:32 +00:00
if ( tableLog < FSE_MIN_TABLELOG ) return ERROR ( GENERIC ) ; /* Unsupported size */
2016-01-27 23:18:06 +00:00
if ( tableLog > FSE_MAX_TABLELOG ) return ERROR ( tableLog_tooLarge ) ; /* Unsupported size */
2015-10-18 21:18:32 +00:00
if ( tableLog < FSE_minTableLog ( total , maxSymbolValue ) ) return ERROR ( GENERIC ) ; /* Too small tableLog, compression potentially impossible */
2015-01-24 00:58:16 +00:00
2017-09-25 23:12:46 +00:00
{ static U32 const rtbTable [ ] = { 0 , 473195 , 504333 , 520860 , 550000 , 700000 , 750000 , 830000 } ;
2015-01-24 00:58:16 +00:00
U64 const scale = 62 - tableLog ;
U64 const step = ( ( U64 ) 1 < < 62 ) / 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 ) ;
2016-01-27 23:18:06 +00:00
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 ) {
2015-01-24 00:58:16 +00:00
normalizedCounter [ s ] = - 1 ;
stillToDistribute - - ;
2016-01-27 23:18:06 +00:00
} else {
2015-01-24 00:58:16 +00:00
short proba = ( short ) ( ( count [ s ] * step ) > > scale ) ;
2016-01-27 23:18:06 +00:00
if ( proba < 8 ) {
2015-02-08 19:26:47 +00:00
U64 restToBeat = vStep * rtbTable [ proba ] ;
2015-01-24 00:58:16 +00:00
proba + = ( count [ s ] * step ) - ( ( U64 ) proba < < scale ) > restToBeat ;
}
2018-02-22 23:44:26 +00:00
if ( proba > largestP ) { largestP = proba ; largest = s ; }
2015-01-24 00:58:16 +00:00
normalizedCounter [ s ] = proba ;
stillToDistribute - = proba ;
2016-01-27 23:18:06 +00:00
} }
if ( - stillToDistribute > = ( normalizedCounter [ largest ] > > 1 ) ) {
2015-02-24 08:05:58 +00:00
/* corner case, need another normalization method */
2016-11-30 23:52:20 +00:00
size_t const errorCode = FSE_normalizeM2 ( normalizedCounter , tableLog , count , total , maxSymbolValue ) ;
2015-01-29 05:51:30 +00:00
if ( FSE_isError ( errorCode ) ) return errorCode ;
2015-01-24 00:58:16 +00:00
}
else normalizedCounter [ largest ] + = ( short ) stillToDistribute ;
}
#if 0
{ /* Print Table (debug) */
2015-01-29 05:51:30 +00:00
U32 s ;
U32 nTotal = 0 ;
2015-01-24 00:58:16 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + )
2018-06-13 23:49:31 +00:00
RAWLOG ( 2 , " %3i: %4i \n " , s , normalizedCounter [ s ] ) ;
2015-01-29 05:51:30 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + )
nTotal + = abs ( normalizedCounter [ s ] ) ;
if ( nTotal ! = ( 1U < < tableLog ) )
2018-06-13 23:49:31 +00:00
RAWLOG ( 2 , " Warning !!! Total == %u != %u !!! " , nTotal , 1U < < tableLog ) ;
2015-01-24 00:58:16 +00:00
getchar ( ) ;
}
# endif
return tableLog ;
}
2015-07-04 23:56:41 +00:00
/* fake FSE_CTable, for raw (uncompressed) input */
size_t FSE_buildCTable_raw ( FSE_CTable * ct , unsigned nbBits )
2015-01-24 00:58:16 +00:00
{
const unsigned tableSize = 1 < < nbBits ;
const unsigned tableMask = tableSize - 1 ;
const unsigned maxSymbolValue = tableMask ;
2016-01-06 00:58:37 +00:00
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 ) ;
2015-01-24 00:58:16 +00:00
unsigned s ;
/* Sanity checks */
2015-10-18 21:18:32 +00:00
if ( nbBits < 1 ) return ERROR ( GENERIC ) ; /* min size */
2015-01-24 00:58:16 +00:00
/* 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 */
2016-03-21 12:24:16 +00:00
{ const U32 deltaNbBits = ( nbBits < < 16 ) - ( 1 < < nbBits ) ;
2016-01-31 01:04:15 +00:00
for ( s = 0 ; s < = maxSymbolValue ; s + + ) {
symbolTT [ s ] . deltaNbBits = deltaNbBits ;
symbolTT [ s ] . deltaFindState = s - 1 ;
2016-03-21 12:24:16 +00:00
} }
2015-01-24 00:58:16 +00:00
return 0 ;
}
2016-11-30 23:52:20 +00:00
/* fake FSE_CTable, for rle input (always same symbol) */
2015-07-04 23:56:41 +00:00
size_t FSE_buildCTable_rle ( FSE_CTable * ct , BYTE symbolValue )
2015-01-24 00:58:16 +00:00
{
2016-01-06 00:58:37 +00:00
void * ptr = ct ;
U16 * tableU16 = ( ( U16 * ) ptr ) + 2 ;
void * FSCTptr = ( U32 * ) ptr + 2 ;
FSE_symbolCompressionTransform * symbolTT = ( FSE_symbolCompressionTransform * ) FSCTptr ;
2015-01-24 00:58:16 +00:00
/* header */
tableU16 [ - 2 ] = ( U16 ) 0 ;
tableU16 [ - 1 ] = ( U16 ) symbolValue ;
/* Build table */
tableU16 [ 0 ] = 0 ;
tableU16 [ 1 ] = 0 ; /* just in case */
/* Build Symbol Transformation Table */
2016-01-28 02:24:53 +00:00
symbolTT [ symbolValue ] . deltaNbBits = 0 ;
symbolTT [ symbolValue ] . deltaFindState = 0 ;
2015-01-24 00:58:16 +00:00
return 0 ;
}
2015-08-07 14:21:00 +00:00
static size_t FSE_compress_usingCTable_generic ( void * dst , size_t dstSize ,
2015-01-24 00:58:16 +00:00
const void * src , size_t srcSize ,
2015-08-07 14:21:00 +00:00
const FSE_CTable * ct , const unsigned fast )
2015-01-24 00:58:16 +00:00
{
const BYTE * const istart = ( const BYTE * ) src ;
const BYTE * const iend = istart + srcSize ;
2016-03-04 18:26:59 +00:00
const BYTE * ip = iend ;
2016-04-22 10:43:18 +00:00
2015-10-18 21:18:32 +00:00
BIT_CStream_t bitC ;
2015-01-24 00:58:16 +00:00
FSE_CState_t CState1 , CState2 ;
/* init */
2016-03-04 18:26:59 +00:00
if ( srcSize < = 2 ) return 0 ;
2016-11-30 23:52:20 +00:00
{ size_t const initError = BIT_initCStream ( & bitC , dst , dstSize ) ;
if ( FSE_isError ( initError ) ) return 0 ; /* not enough space available to write a bitstream */ }
2015-01-24 00:58:16 +00:00
2015-10-18 21:18:32 +00:00
# define FSE_FLUSHBITS(s) (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
2015-08-07 14:21:00 +00:00
2016-01-28 02:24:53 +00:00
if ( srcSize & 1 ) {
2016-03-04 18:26:59 +00:00
FSE_initCState2 ( & CState1 , ct , * - - ip ) ;
FSE_initCState2 ( & CState2 , ct , * - - ip ) ;
2015-07-04 23:56:41 +00:00
FSE_encodeSymbol ( & bitC , & CState1 , * - - ip ) ;
2015-08-07 14:21:00 +00:00
FSE_FLUSHBITS ( & bitC ) ;
2016-03-04 18:26:59 +00:00
} else {
FSE_initCState2 ( & CState2 , ct , * - - ip ) ;
FSE_initCState2 ( & CState1 , ct , * - - ip ) ;
2015-01-24 00:58:16 +00:00
}
/* join to mod 4 */
2016-03-04 18:26:59 +00:00
srcSize - = 2 ;
2016-01-28 02:24:53 +00:00
if ( ( sizeof ( bitC . bitContainer ) * 8 > FSE_MAX_TABLELOG * 4 + 7 ) & & ( srcSize & 2 ) ) { /* test bit 2 */
2015-07-04 23:56:41 +00:00
FSE_encodeSymbol ( & bitC , & CState2 , * - - ip ) ;
FSE_encodeSymbol ( & bitC , & CState1 , * - - ip ) ;
2015-08-07 14:21:00 +00:00
FSE_FLUSHBITS ( & bitC ) ;
2015-01-24 00:58:16 +00:00
}
/* 2 or 4 encoding per loop */
2016-11-30 23:52:20 +00:00
while ( ip > istart ) {
2016-04-22 10:43:18 +00:00
2015-07-04 23:56:41 +00:00
FSE_encodeSymbol ( & bitC , & CState2 , * - - ip ) ;
2015-01-24 00:58:16 +00:00
2015-08-02 00:19:09 +00:00
if ( sizeof ( bitC . bitContainer ) * 8 < FSE_MAX_TABLELOG * 2 + 7 ) /* this test must be static */
2015-08-07 14:21:00 +00:00
FSE_FLUSHBITS ( & bitC ) ;
2015-01-24 00:58:16 +00:00
2015-07-04 23:56:41 +00:00
FSE_encodeSymbol ( & bitC , & CState1 , * - - ip ) ;
2015-01-24 00:58:16 +00:00
2016-01-28 02:24:53 +00:00
if ( sizeof ( bitC . bitContainer ) * 8 > FSE_MAX_TABLELOG * 4 + 7 ) { /* this test must be static */
2015-07-04 23:56:41 +00:00
FSE_encodeSymbol ( & bitC , & CState2 , * - - ip ) ;
FSE_encodeSymbol ( & bitC , & CState1 , * - - ip ) ;
2015-01-24 00:58:16 +00:00
}
2015-08-07 14:21:00 +00:00
FSE_FLUSHBITS ( & bitC ) ;
2015-01-24 00:58:16 +00:00
}
FSE_flushCState ( & bitC , & CState2 ) ;
FSE_flushCState ( & bitC , & CState1 ) ;
2015-10-18 21:18:32 +00:00
return BIT_closeCStream ( & bitC ) ;
2015-01-24 00:58:16 +00:00
}
2015-08-07 14:21:00 +00:00
size_t FSE_compress_usingCTable ( void * dst , size_t dstSize ,
const void * src , size_t srcSize ,
const FSE_CTable * ct )
{
2016-11-30 23:52:20 +00:00
unsigned const fast = ( dstSize > = FSE_BLOCKBOUND ( srcSize ) ) ;
2015-01-24 00:58:16 +00:00
2015-08-07 14:21:00 +00:00
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 ) ;
}
2015-01-24 00:58:16 +00:00
2015-08-07 14:21:00 +00:00
size_t FSE_compressBound ( size_t size ) { return FSE_COMPRESSBOUND ( size ) ; }
2017-07-25 19:52:01 +00:00
# define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
2016-12-02 00:24:04 +00:00
# define CHECK_F(f) { CHECK_V_F(_var_err__, f); }
2016-11-30 23:52:20 +00:00
/* FSE_compress_wksp() :
* Same as FSE_compress2 ( ) , but using an externally allocated scratch buffer ( ` workSpace ` ) .
2016-12-01 00:46:13 +00:00
* ` wkspSize ` size must be ` ( 1 < < tableLog ) ` .
2016-11-30 23:52:20 +00:00
*/
2016-12-01 00:46:13 +00:00
size_t FSE_compress_wksp ( void * dst , size_t dstSize , const void * src , size_t srcSize , unsigned maxSymbolValue , unsigned tableLog , void * workSpace , size_t wkspSize )
2015-01-24 00:58:16 +00:00
{
BYTE * const ostart = ( BYTE * ) dst ;
BYTE * op = ostart ;
BYTE * const oend = ostart + dstSize ;
U32 count [ FSE_MAX_SYMBOL_VALUE + 1 ] ;
S16 norm [ FSE_MAX_SYMBOL_VALUE + 1 ] ;
2016-12-01 00:46:13 +00:00
FSE_CTable * CTable = ( FSE_CTable * ) workSpace ;
size_t const CTableSize = FSE_CTABLE_SIZE_U32 ( tableLog , maxSymbolValue ) ;
void * scratchBuffer = ( void * ) ( CTable + CTableSize ) ;
size_t const scratchBufferSize = wkspSize - ( CTableSize * sizeof ( FSE_CTable ) ) ;
2015-01-24 00:58:16 +00:00
2015-08-07 14:21:00 +00:00
/* init conditions */
2016-12-01 00:46:13 +00:00
if ( wkspSize < FSE_WKSP_SIZE_U32 ( tableLog , maxSymbolValue ) ) return ERROR ( tableLog_tooLarge ) ;
2016-11-30 23:52:20 +00:00
if ( srcSize < = 1 ) return 0 ; /* Not compressible */
2015-01-24 00:58:16 +00:00
if ( ! maxSymbolValue ) maxSymbolValue = FSE_MAX_SYMBOL_VALUE ;
if ( ! tableLog ) tableLog = FSE_DEFAULT_TABLELOG ;
/* Scan input and build symbol stats */
2018-06-13 23:49:31 +00:00
{ CHECK_V_F ( maxCount , HIST_count_wksp ( count , & maxSymbolValue , src , srcSize , ( unsigned * ) scratchBuffer ) ) ;
2016-11-30 23:52:20 +00:00
if ( maxCount = = srcSize ) return 1 ; /* only a single symbol in src : rle */
if ( maxCount = = 1 ) return 0 ; /* each symbol present maximum once => not compressible */
if ( maxCount < ( srcSize > > 7 ) ) return 0 ; /* Heuristic : not compressible enough */
}
2015-01-24 00:58:16 +00:00
tableLog = FSE_optimalTableLog ( tableLog , srcSize , maxSymbolValue ) ;
2016-12-02 00:13:35 +00:00
CHECK_F ( FSE_normalizeCount ( norm , tableLog , count , srcSize , maxSymbolValue ) ) ;
2015-01-24 00:58:16 +00:00
/* Write table description header */
2016-12-02 00:24:04 +00:00
{ CHECK_V_F ( nc_err , FSE_writeNCount ( op , oend - op , norm , maxSymbolValue , tableLog ) ) ;
2016-11-30 23:52:20 +00:00
op + = nc_err ;
}
2015-01-24 00:58:16 +00:00
/* Compress */
2016-12-01 00:46:13 +00:00
CHECK_F ( FSE_buildCTable_wksp ( CTable , norm , maxSymbolValue , tableLog , scratchBuffer , scratchBufferSize ) ) ;
2016-12-02 00:24:04 +00:00
{ CHECK_V_F ( cSize , FSE_compress_usingCTable ( op , oend - op , src , srcSize , CTable ) ) ;
2016-11-30 23:52:20 +00:00
if ( cSize = = 0 ) return 0 ; /* not enough space for compressed data */
op + = cSize ;
}
2015-01-24 00:58:16 +00:00
/* check compressibility */
2016-11-30 23:52:20 +00:00
if ( ( size_t ) ( op - ostart ) > = srcSize - 1 ) return 0 ;
2015-01-24 00:58:16 +00:00
return op - ostart ;
}
2016-12-01 00:46:13 +00:00
typedef struct {
FSE_CTable CTable_max [ FSE_CTABLE_SIZE_U32 ( FSE_MAX_TABLELOG , FSE_MAX_SYMBOL_VALUE ) ] ;
BYTE scratchBuffer [ 1 < < FSE_MAX_TABLELOG ] ;
} fseWkspMax_t ;
2016-11-30 23:52:20 +00:00
size_t FSE_compress2 ( void * dst , size_t dstCapacity , const void * src , size_t srcSize , unsigned maxSymbolValue , unsigned tableLog )
{
2016-12-01 00:46:13 +00:00
fseWkspMax_t scratchBuffer ;
2018-06-13 23:49:31 +00:00
DEBUG_STATIC_ASSERT ( sizeof ( scratchBuffer ) > = FSE_WKSP_SIZE_U32 ( FSE_MAX_TABLELOG , FSE_MAX_SYMBOL_VALUE ) ) ; /* compilation failures here means scratchBuffer is not large enough */
2016-11-30 23:52:20 +00:00
if ( tableLog > FSE_MAX_TABLELOG ) return ERROR ( tableLog_tooLarge ) ;
2016-12-01 00:46:13 +00:00
return FSE_compress_wksp ( dst , dstCapacity , src , srcSize , maxSymbolValue , tableLog , & scratchBuffer , sizeof ( scratchBuffer ) ) ;
2016-11-30 23:52:20 +00:00
}
size_t FSE_compress ( void * dst , size_t dstCapacity , const void * src , size_t srcSize )
2015-01-24 00:58:16 +00:00
{
2016-11-30 23:52:20 +00:00
return FSE_compress2 ( dst , dstCapacity , src , srcSize , FSE_MAX_SYMBOL_VALUE , FSE_DEFAULT_TABLELOG ) ;
2015-01-24 00:58:16 +00:00
}
2015-07-25 23:23:57 +00:00
# endif /* FSE_COMMONDEFS_ONLY */