Skip to content

Commit 48c55a4

Browse files
inikepinikep
committed
updated lz5 to t131b
1 parent bbabddc commit 48c55a4

File tree

4 files changed

+114
-62
lines changed

4 files changed

+114
-62
lines changed

‎.gitignore

+3
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,9 @@
22
_codelite/
33
_visual/
44

5+
# Archives
6+
*.zip
7+
58
# Object files
69
*.o
710
*.ko

‎lz5/lz5.c

+54-24
Original file line numberDiff line numberDiff line change
@@ -305,6 +305,7 @@ static const int LZ5_minLength = (MFLIMIT+1);
305305

306306
#define MAXD_LOG 22
307307
#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
308+
#define LZ5_DICT_SIZE (1 << MAXD_LOG)
308309

309310
#define ML_BITS 3
310311
#define ML_MASK ((1U<<ML_BITS)-1)
@@ -906,14 +907,29 @@ static int LZ5_compress_destSize_generic(
906907
op--;
907908
goto _last_literals;
908909
}
909-
if (litLength>=RUN_MASK)
910+
911+
if (ip-match < (1<<10))
910912
{
911-
unsigned len = litLength - RUN_MASK;
912-
*token=(RUN_MASK<<ML_BITS);
913-
for(; len >= 255 ; len-=255) *op++ = 255;
914-
*op++ = (BYTE)len;
913+
if (litLength>=RUN_MASK2)
914+
{
915+
int len = (int)litLength-RUN_MASK2;
916+
*token=(RUN_MASK2<<ML_BITS);
917+
for(; len >= 255 ; len-=255) *op++ = 255;
918+
*op++ = (BYTE)len;
919+
}
920+
else *token = (BYTE)(litLength<<ML_BITS);
921+
}
922+
else
923+
{
924+
if (litLength>=RUN_MASK)
925+
{
926+
int len = (int)litLength-RUN_MASK;
927+
*token=(RUN_MASK<<ML_BITS);
928+
for(; len >= 255 ; len-=255) *op++ = 255;
929+
*op++ = (BYTE)len;
930+
}
931+
else *token = (BYTE)(litLength<<ML_BITS);
915932
}
916-
else *token = (BYTE)(litLength<<ML_BITS);
917933

918934
/* Copy Literals */
919935
LZ5_wildCopy(op, anchor, op+litLength);
@@ -922,7 +938,21 @@ static int LZ5_compress_destSize_generic(
922938

923939
_next_match:
924940
/* Encode Offset */
925-
LZ5_writeLE16(op, (U16)(ip-match)); op+=2;
941+
if (ip-match < (1<<10))
942+
{
943+
*token+=((4+((ip-match)>>8))<<ML_RUN_BITS2);
944+
*op++=(ip-match);
945+
}
946+
else
947+
if (ip-match < (1<<16))
948+
{
949+
LZ5_writeLE16(op, (U16)(ip-match)); op+=2;
950+
}
951+
else
952+
{
953+
*token+=(1<<ML_RUN_BITS);
954+
LZ5_writeLE24(op, (U32)(ip-match)); op+=3;
955+
}
926956

927957
/* Encode MatchLength */
928958
{
@@ -1079,8 +1109,8 @@ int LZ5_loadDict (LZ5_stream_t* LZ5_dict, const char* dictionary, int dictSize)
10791109
return 0;
10801110
}
10811111

1082-
if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
1083-
dict->currentOffset += 64 KB;
1112+
if ((dictEnd - p) > LZ5_DICT_SIZE) p = dictEnd - LZ5_DICT_SIZE;
1113+
dict->currentOffset += LZ5_DICT_SIZE;
10841114
base = p - dict->currentOffset;
10851115
dict->dictionary = p;
10861116
dict->dictSize = (U32)(dictEnd - p);
@@ -1102,16 +1132,16 @@ static void LZ5_renormDictT(LZ5_stream_t_internal* LZ5_dict, const BYTE* src)
11021132
((size_t)LZ5_dict->currentOffset > (size_t)src)) /* address space overflow */
11031133
{
11041134
/* rescale hash table */
1105-
U32 delta = LZ5_dict->currentOffset - 64 KB;
1135+
U32 delta = LZ5_dict->currentOffset - LZ5_DICT_SIZE;
11061136
const BYTE* dictEnd = LZ5_dict->dictionary + LZ5_dict->dictSize;
11071137
int i;
11081138
for (i=0; i<HASH_SIZE_U32; i++)
11091139
{
11101140
if (LZ5_dict->hashTable[i] < delta) LZ5_dict->hashTable[i]=0;
11111141
else LZ5_dict->hashTable[i] -= delta;
11121142
}
1113-
LZ5_dict->currentOffset = 64 KB;
1114-
if (LZ5_dict->dictSize > 64 KB) LZ5_dict->dictSize = 64 KB;
1143+
LZ5_dict->currentOffset = LZ5_DICT_SIZE;
1144+
if (LZ5_dict->dictSize > LZ5_DICT_SIZE) LZ5_dict->dictSize = LZ5_DICT_SIZE;
11151145
LZ5_dict->dictionary = dictEnd - LZ5_dict->dictSize;
11161146
}
11171147
}
@@ -1134,7 +1164,7 @@ int LZ5_compress_fast_continue (LZ5_stream_t* LZ5_stream, const char* source, ch
11341164
if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd))
11351165
{
11361166
streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
1137-
if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
1167+
if (streamPtr->dictSize > LZ5_DICT_SIZE) streamPtr->dictSize = LZ5_DICT_SIZE;
11381168
if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
11391169
streamPtr->dictionary = dictEnd - streamPtr->dictSize;
11401170
}
@@ -1144,7 +1174,7 @@ int LZ5_compress_fast_continue (LZ5_stream_t* LZ5_stream, const char* source, ch
11441174
if (dictEnd == (const BYTE*)source)
11451175
{
11461176
int result;
1147-
if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
1177+
if ((streamPtr->dictSize < LZ5_DICT_SIZE) && (streamPtr->dictSize < streamPtr->currentOffset))
11481178
result = LZ5_compress_generic(LZ5_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, dictSmall, acceleration);
11491179
else
11501180
result = LZ5_compress_generic(LZ5_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, withPrefix64k, noDictIssue, acceleration);
@@ -1156,7 +1186,7 @@ int LZ5_compress_fast_continue (LZ5_stream_t* LZ5_stream, const char* source, ch
11561186
/* external dictionary mode */
11571187
{
11581188
int result;
1159-
if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
1189+
if ((streamPtr->dictSize < LZ5_DICT_SIZE) && (streamPtr->dictSize < streamPtr->currentOffset))
11601190
result = LZ5_compress_generic(LZ5_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, dictSmall, acceleration);
11611191
else
11621192
result = LZ5_compress_generic(LZ5_stream, source, dest, inputSize, maxOutputSize, limitedOutput, byU32, usingExtDict, noDictIssue, acceleration);
@@ -1194,7 +1224,7 @@ int LZ5_saveDict (LZ5_stream_t* LZ5_dict, char* safeBuffer, int dictSize)
11941224
LZ5_stream_t_internal* dict = (LZ5_stream_t_internal*) LZ5_dict;
11951225
const BYTE* previousDictEnd = dict->dictionary + dict->dictSize;
11961226

1197-
if ((U32)dictSize > 64 KB) dictSize = 64 KB; /* useless to define a dictionary > 64 KB */
1227+
if ((U32)dictSize > LZ5_DICT_SIZE) dictSize = LZ5_DICT_SIZE; /* useless to define a dictionary > LZ5_DICT_SIZE */
11981228
if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;
11991229

12001230
memmove(safeBuffer, previousDictEnd - dictSize, dictSize);
@@ -1246,7 +1276,7 @@ FORCE_INLINE int LZ5_decompress_generic(
12461276
const int dec64table[] = {0, 0, 0, -1, 0, 1, 2, 3};
12471277

12481278
const int safeDecode = (endOnInput==endOnInputSize);
1249-
const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB)));
1279+
const int checkOffset = ((safeDecode) && (dictSize < (int)(LZ5_DICT_SIZE)));
12501280

12511281

12521282
/* Special cases */
@@ -1298,7 +1328,7 @@ FORCE_INLINE int LZ5_decompress_generic(
12981328

12991329
/* copy literals */
13001330
cpy = op+length;
1301-
if (((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(2+1+LASTLITERALS))) )
1331+
if (((endOnInput) && ((cpy>(partialDecoding?oexit:oend-MFLIMIT)) || (ip+length>iend-(1+1+LASTLITERALS))) )
13021332
|| ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)))
13031333
{
13041334
if (partialDecoding)
@@ -1440,7 +1470,7 @@ int LZ5_decompress_safe_partial(const char* source, char* dest, int compressedSi
14401470

14411471
int LZ5_decompress_fast(const char* source, char* dest, int originalSize)
14421472
{
1443-
return LZ5_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - 64 KB), NULL, 64 KB);
1473+
return LZ5_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)(dest - LZ5_DICT_SIZE), NULL, LZ5_DICT_SIZE);
14441474
}
14451475

14461476

@@ -1567,8 +1597,8 @@ FORCE_INLINE int LZ5_decompress_usingDict_generic(const char* source, char* dest
15671597
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest, NULL, 0);
15681598
if (dictStart+dictSize == dest)
15691599
{
1570-
if (dictSize >= (int)(64 KB - 1))
1571-
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-64 KB, NULL, 0);
1600+
if (dictSize >= (int)(LZ5_DICT_SIZE - 1))
1601+
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, withPrefix64k, (BYTE*)dest-LZ5_DICT_SIZE, NULL, 0);
15721602
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, noDict, (BYTE*)dest-dictSize, NULL, 0);
15731603
}
15741604
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, safe, full, 0, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize);
@@ -1639,20 +1669,20 @@ void* LZ5_create (char* inputBuffer)
16391669
char* LZ5_slideInputBuffer (void* LZ5_Data)
16401670
{
16411671
LZ5_stream_t_internal* ctx = (LZ5_stream_t_internal*)LZ5_Data;
1642-
int dictSize = LZ5_saveDict((LZ5_stream_t*)LZ5_Data, (char*)ctx->bufferStart, 64 KB);
1672+
int dictSize = LZ5_saveDict((LZ5_stream_t*)LZ5_Data, (char*)ctx->bufferStart, LZ5_DICT_SIZE);
16431673
return (char*)(ctx->bufferStart + dictSize);
16441674
}
16451675

16461676
/* Obsolete streaming decompression functions */
16471677

16481678
int LZ5_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
16491679
{
1650-
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
1680+
return LZ5_decompress_generic(source, dest, compressedSize, maxOutputSize, endOnInputSize, full, 0, withPrefix64k, (BYTE*)dest - LZ5_DICT_SIZE, NULL, LZ5_DICT_SIZE);
16511681
}
16521682

16531683
int LZ5_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
16541684
{
1655-
return LZ5_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 64 KB);
1685+
return LZ5_decompress_generic(source, dest, 0, originalSize, endOnOutputSize, full, 0, withPrefix64k, (BYTE*)dest - LZ5_DICT_SIZE, NULL, LZ5_DICT_SIZE);
16561686
}
16571687

16581688
#endif /* LZ5_COMMONDEFS_ONLY */

‎lz5/lz5hc.c

+51-31
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ static const int g_maxCompressionLevel = 16;
9292
/**************************************
9393
* Local Types
9494
**************************************/
95-
typedef struct
95+
struct LZ5HC_Data_s
9696
{
9797
U32* hashTable;
9898
U32* chainTable;
@@ -104,7 +104,7 @@ typedef struct
104104
U32 lowLimit; /* below that point, no more dict */
105105
U32 nextToUpdate; /* index from which to continue dictionary update */
106106
U32 compressionLevel;
107-
} LZ5HC_Data_Structure;
107+
};
108108

109109

110110
/**************************************
@@ -584,6 +584,29 @@ int LZ5_compress_HC_extStateHC (void* state, const char* src, char* dst, int src
584584
return LZ5HC_compress_generic (state, src, dst, srcSize, maxDstSize, compressionLevel, noLimit);
585585
}
586586

587+
int LZ5_alloc_mem_HC(LZ5HC_Data_Structure* statePtr)
588+
{
589+
statePtr->hashTable = ALLOCATOR(1, sizeof(U32)*HASHTABLESIZE);
590+
if (!statePtr->hashTable)
591+
return 0;
592+
593+
statePtr->chainTable = ALLOCATOR(1, sizeof(U32)*MAXD);
594+
if (!statePtr->chainTable)
595+
{
596+
FREEMEM(statePtr->hashTable);
597+
statePtr->hashTable = NULL;
598+
return 0;
599+
}
600+
601+
return 1;
602+
}
603+
604+
void LZ5_free_mem_HC(LZ5HC_Data_Structure* statePtr)
605+
{
606+
if (statePtr->chainTable) FREEMEM(statePtr->chainTable);
607+
if (statePtr->hashTable) FREEMEM(statePtr->hashTable);
608+
}
609+
587610
int LZ5_compress_HC(const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel)
588611
{
589612
#if LZ5HC_HEAPMODE==1
@@ -594,17 +617,13 @@ int LZ5_compress_HC(const char* src, char* dst, int srcSize, int maxDstSize, int
594617
#endif
595618

596619
int cSize = 0;
597-
statePtr->hashTable = ALLOCATOR(1, sizeof(U32)*HASHTABLESIZE);
598-
if (statePtr->hashTable)
599-
{
600-
statePtr->chainTable = ALLOCATOR(1, sizeof(U32)*MAXD);
601-
if (statePtr->chainTable)
602-
{
603-
cSize = LZ5_compress_HC_extStateHC(statePtr, src, dst, srcSize, maxDstSize, compressionLevel);
604-
FREEMEM(statePtr->chainTable);
605-
}
606-
FREEMEM(statePtr->hashTable);
607-
}
620+
621+
if (!LZ5_alloc_mem_HC(statePtr))
622+
return 0;
623+
624+
cSize = LZ5_compress_HC_extStateHC(statePtr, src, dst, srcSize, maxDstSize, compressionLevel);
625+
626+
LZ5_free_mem_HC(statePtr);
608627

609628
#if LZ5HC_HEAPMODE==1
610629
free(statePtr);
@@ -624,29 +643,19 @@ LZ5_streamHC_t* LZ5_createStreamHC(void)
624643
if (!statePtr)
625644
return NULL;
626645

627-
statePtr->hashTable = ALLOCATOR(1, sizeof(U32)*HASHTABLESIZE);
628-
if (!statePtr->hashTable)
646+
if (!LZ5_alloc_mem_HC(statePtr))
629647
{
630648
FREEMEM(statePtr);
631649
return NULL;
632650
}
633-
634-
statePtr->chainTable = ALLOCATOR(1, sizeof(U32)*MAXD);
635-
if (!statePtr->chainTable)
636-
{
637-
FREEMEM(statePtr->hashTable);
638-
FREEMEM(statePtr);
639-
return NULL;
640-
}
641651

642652
return (LZ5_streamHC_t*) statePtr;
643653
}
644654

645-
int LZ5_freeStreamHC (LZ5_streamHC_t* LZ5_streamHCPtr)
655+
int LZ5_freeStreamHC (LZ5_streamHC_t* LZ5_streamHCPtr)
646656
{
647657
LZ5HC_Data_Structure* statePtr = (LZ5HC_Data_Structure*)LZ5_streamHCPtr;
648-
FREEMEM(statePtr->chainTable);
649-
FREEMEM(statePtr->hashTable);
658+
LZ5_free_mem_HC(statePtr);
650659
free(LZ5_streamHCPtr);
651660
return 0;
652661
}
@@ -663,10 +672,10 @@ void LZ5_resetStreamHC (LZ5_streamHC_t* LZ5_streamHCPtr, int compressionLevel)
663672
int LZ5_loadDictHC (LZ5_streamHC_t* LZ5_streamHCPtr, const char* dictionary, int dictSize)
664673
{
665674
LZ5HC_Data_Structure* ctxPtr = (LZ5HC_Data_Structure*) LZ5_streamHCPtr;
666-
if (dictSize > 64 KB)
675+
if (dictSize > LZ5_DICT_SIZE)
667676
{
668-
dictionary += dictSize - 64 KB;
669-
dictSize = 64 KB;
677+
dictionary += dictSize - LZ5_DICT_SIZE;
678+
dictSize = LZ5_DICT_SIZE;
670679
}
671680
LZ5HC_init (ctxPtr, (const BYTE*)dictionary);
672681
if (dictSize >= 4) LZ5HC_Insert (ctxPtr, (const BYTE*)dictionary +(dictSize-3));
@@ -702,7 +711,7 @@ static int LZ5_compressHC_continue_generic (LZ5HC_Data_Structure* ctxPtr,
702711
if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 GB)
703712
{
704713
size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->base) - ctxPtr->dictLimit;
705-
if (dictSize > 64 KB) dictSize = 64 KB;
714+
if (dictSize > LZ5_DICT_SIZE) dictSize = LZ5_DICT_SIZE;
706715

707716
LZ5_loadDictHC((LZ5_streamHC_t*)ctxPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
708717
}
@@ -742,7 +751,7 @@ int LZ5_saveDictHC (LZ5_streamHC_t* LZ5_streamHCPtr, char* safeBuffer, int dictS
742751
{
743752
LZ5HC_Data_Structure* streamPtr = (LZ5HC_Data_Structure*)LZ5_streamHCPtr;
744753
int prefixSize = (int)(streamPtr->end - (streamPtr->base + streamPtr->dictLimit));
745-
if (dictSize > 64 KB) dictSize = 64 KB;
754+
if (dictSize > LZ5_DICT_SIZE) dictSize = LZ5_DICT_SIZE;
746755
if (dictSize < 4) dictSize = 0;
747756
if (dictSize > prefixSize) dictSize = prefixSize;
748757
memmove(safeBuffer, streamPtr->end - dictSize, dictSize);
@@ -757,3 +766,14 @@ int LZ5_saveDictHC (LZ5_streamHC_t* LZ5_streamHCPtr, char* safeBuffer, int dictS
757766
return dictSize;
758767
}
759768

769+
/***********************************
770+
* Deprecated Functions
771+
***********************************/
772+
/* Deprecated compression functions */
773+
/* These functions are planned to start generate warnings by r131 approximately */
774+
int LZ5_compressHC(const char* src, char* dst, int srcSize) { return LZ5_compress_HC (src, dst, srcSize, LZ5_compressBound(srcSize), 0); }
775+
int LZ5_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ5_compress_HC(src, dst, srcSize, maxDstSize, 0); }
776+
int LZ5_compressHC_continue (LZ5_streamHC_t* ctx, const char* src, char* dst, int srcSize) { return LZ5_compress_HC_continue (ctx, src, dst, srcSize, LZ5_compressBound(srcSize)); }
777+
int LZ5_compressHC_limitedOutput_continue (LZ5_streamHC_t* ctx, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ5_compress_HC_continue (ctx, src, dst, srcSize, maxDstSize); }
778+
int LZ5_compressHC_withStateHC (void* state, const char* src, char* dst, int srcSize) { return LZ5_compress_HC_extStateHC (state, src, dst, srcSize, LZ5_compressBound(srcSize), 0); }
779+
int LZ5_compressHC_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ5_compress_HC_extStateHC (state, src, dst, srcSize, maxDstSize, 0); }

‎lz5/lz5hc.h

+6-7
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,10 @@ LZ5_compress_HC :
6666
Decompression functions are provided within LZ5 source code (see "lz5.h") (BSD license)
6767
*/
6868

69+
typedef struct LZ5HC_Data_s LZ5HC_Data_Structure;
70+
71+
int LZ5_alloc_mem_HC(LZ5HC_Data_Structure* statePtr);
72+
void LZ5_free_mem_HC(LZ5HC_Data_Structure* statePtr);
6973

7074
int LZ5_sizeofStateHC(void);
7175
int LZ5_compress_HC_extStateHC(void* state, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
@@ -165,15 +169,10 @@ int LZ5_saveDictHC (LZ5_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSi
165169
/* these functions are planned to trigger warning messages by r131 approximately */
166170
int LZ5_compressHC (const char* source, char* dest, int inputSize);
167171
int LZ5_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
168-
int LZ5_compressHC2 (const char* source, char* dest, int inputSize, int compressionLevel);
169-
int LZ5_compressHC2_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
170-
int LZ5_compressHC_withStateHC (void* state, const char* source, char* dest, int inputSize);
171-
int LZ5_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
172-
int LZ5_compressHC2_withStateHC (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
173-
int LZ5_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
174172
int LZ5_compressHC_continue (LZ5_streamHC_t* LZ5_streamHCPtr, const char* source, char* dest, int inputSize);
175173
int LZ5_compressHC_limitedOutput_continue (LZ5_streamHC_t* LZ5_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
176-
174+
int LZ5_compressHC_withStateHC (void* state, const char* source, char* dest, int inputSize);
175+
int LZ5_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
177176

178177
#if defined (__cplusplus)
179178
}

0 commit comments

Comments
 (0)