//**************************************\r
// Tuning parameters\r
//**************************************\r
-// COMPRESSIONLEVEL :\r
-// Increasing this value improves compression ratio\r
-// Lowering this value reduces memory usage\r
-// Reduced memory usage typically improves speed, due to cache effect (ex : L1 32KB for Intel, L1 64KB for AMD)\r
-// Memory usage formula : N->2^(N+2) Bytes (examples : 12 -> 16KB ; 17 -> 512KB)\r
-#define COMPRESSIONLEVEL 12\r
-\r
-// NOTCOMPRESSIBLE_CONFIRMATION :\r
+// MEMORY_USAGE :\r
+// Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)\r
+// Increasing memory usage improves compression ratio\r
+// Reduced memory usage can improve speed, due to cache effect\r
+// Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache\r
+#define MEMORY_USAGE 14\r
+\r
+// NOTCOMPRESSIBLE_DETECTIONLEVEL :\r
// Decreasing this value will make the algorithm skip faster data segments considered "incompressible"\r
// This may decrease compression ratio dramatically, but will be faster on incompressible data\r
// Increasing this value will make the algorithm search more before declaring a segment "incompressible"\r
// This could improve compression a bit, but will be slower on incompressible data\r
// The default value (6) is recommended\r
-#define NOTCOMPRESSIBLE_CONFIRMATION 6\r
-\r
-// LZ4_COMPRESSMIN :\r
-// Compression function will *fail* if it is not successful at compressing input by at least LZ4_COMPRESSMIN bytes\r
-// Since the compression function stops working prematurely, it results in a speed gain\r
-// The output however is unusable. Compression function result will be zero.\r
-// Default : 0 = disabled\r
-#define LZ4_COMPRESSMIN 0\r
+#define NOTCOMPRESSIBLE_DETECTIONLEVEL 6\r
\r
// BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE :\r
-// This will provide a boost to performance for big endian cpu, but the resulting compressed stream will be incompatible with little-endian CPU.\r
-// You can set this option to 1 in situations where data will stay within closed environment\r
+// This will provide a small boost to performance for big endian cpu, but the resulting compressed stream will be incompatible with little-endian CPU.\r
+// You can set this option to 1 in situations where data will remain within closed environment\r
// This option is useless on Little_Endian CPU (such as x86)\r
//#define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1\r
\r
\r
#ifdef _MSC_VER // Visual Studio\r
# define inline __forceinline // Visual is not C99, but supports some kind of inline\r
+# include <intrin.h> // For Visual 2005\r
# if LZ4_ARCH64 // 64-bit\r
# pragma intrinsic(_BitScanForward64) // For Visual 2005\r
# pragma intrinsic(_BitScanReverse64) // For Visual 2005\r
//**************************************\r
#define MINMATCH 4\r
\r
-#define HASH_LOG COMPRESSIONLEVEL\r
+#define HASH_LOG (MEMORY_USAGE-2)\r
#define HASHTABLESIZE (1 << HASH_LOG)\r
#define HASH_MASK (HASHTABLESIZE - 1)\r
\r
-#define SKIPSTRENGTH (NOTCOMPRESSIBLE_CONFIRMATION>2?NOTCOMPRESSIBLE_CONFIRMATION:2)\r
+#define SKIPSTRENGTH (NOTCOMPRESSIBLE_DETECTIONLEVEL>2?NOTCOMPRESSIBLE_DETECTIONLEVEL:2)\r
#define STACKLIMIT 13\r
#define HEAPMODE (HASH_LOG>STACKLIMIT) // Defines if memory is allocated into the stack (local variable), or into the heap (malloc()).\r
#define COPYLENGTH 8\r
//****************************\r
#if LZ4_ARCH64\r
\r
-inline static int LZ4_NbCommonBytes (register U64 val)\r
+static inline int LZ4_NbCommonBytes (register U64 val)\r
{\r
#if defined(LZ4_BIG_ENDIAN)\r
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)\r
\r
#else\r
\r
-inline static int LZ4_NbCommonBytes (register U32 val)\r
+static inline int LZ4_NbCommonBytes (register U32 val)\r
{\r
#if defined(LZ4_BIG_ENDIAN)\r
#if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)\r
#endif\r
\r
\r
-//****************************\r
-// Public functions\r
-//****************************\r
-\r
-int LZ4_compressBound(int isize)\r
-{\r
- return (isize + (isize/255) + 16);\r
-}\r
-\r
-\r
\r
//******************************\r
// Compression functions\r
//******************************\r
\r
-int LZ4_compressCtx(void** ctx,\r
+// LZ4_compressCtx :\r
+// -----------------\r
+// Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.\r
+// If it cannot achieve it, compression will stop, and result of the function will be zero.\r
+// return : the number of bytes written in buffer 'dest', or 0 if the compression fails\r
+\r
+static inline int LZ4_compressCtx(void** ctx,\r
const char* source,\r
char* dest,\r
- int isize)\r
+ int isize,\r
+ int maxOutputSize)\r
{\r
#if HEAPMODE\r
struct refTables *srt = (struct refTables *) (*ctx);\r
#define matchlimit (iend - LASTLITERALS)\r
\r
BYTE* op = (BYTE*) dest;\r
+ BYTE* const oend = op + maxOutputSize;\r
\r
int len, length;\r
const int skipStrength = SKIPSTRENGTH;\r
while ((ip>anchor) && (ref>(BYTE*)source) && unlikely(ip[-1]==ref[-1])) { ip--; ref--; }\r
\r
// Encode Literal length\r
- length = ip - anchor;\r
+ length = (int)(ip - anchor);\r
token = op++;\r
+ if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) >= oend) return 0; // Check output limit\r
+#ifdef _MSC_VER\r
+ if (length>=(int)RUN_MASK) \r
+ { \r
+ int len = length-RUN_MASK; \r
+ *token=(RUN_MASK<<ML_BITS); \r
+ if (len>254)\r
+ {\r
+ do { *op++ = 255; len -= 255; } while (len>254);\r
+ *op++ = (BYTE)len; \r
+ memcpy(op, anchor, length);\r
+ op += length;\r
+ goto _next_match;\r
+ }\r
+ else\r
+ *op++ = (BYTE)len; \r
+ }\r
+ else *token = (length<<ML_BITS);\r
+#else\r
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }\r
else *token = (length<<ML_BITS);\r
+#endif\r
\r
// Copy Literals\r
LZ4_BLINDCOPY(anchor, op, length);\r
\r
_next_match:\r
// Encode Offset\r
- LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref);\r
+ LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(ip-ref));\r
\r
// Start Counting\r
ip+=MINMATCH; ref+=MINMATCH; // MinMatch verified\r
_endCount:\r
\r
// Encode MatchLength\r
- len = (ip - anchor);\r
+ len = (int)(ip - anchor);\r
+ if unlikely(op + (1 + LASTLITERALS) + (len>>8) >= oend) return 0; // Check output limit\r
if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }\r
else *token += len;\r
\r
_last_literals:\r
// Encode Last Literals\r
{\r
- int lastRun = iend - anchor;\r
- if ((LZ4_COMPRESSMIN>0) && (((op - (BYTE*)dest) + lastRun + 1 + ((lastRun-15)/255)) > isize - LZ4_COMPRESSMIN)) return 0;\r
+ int lastRun = (int)(iend - anchor);\r
+ if (((char*)op - dest) + lastRun + 1 + ((lastRun-15)/255) >= maxOutputSize) return 0;\r
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }\r
else *op++ = (lastRun<<ML_BITS);\r
memcpy(op, anchor, iend - anchor);\r
#define HASH64KTABLESIZE (1U<<HASHLOG64K)\r
#define LZ4_HASH64K_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-HASHLOG64K))\r
#define LZ4_HASH64K_VALUE(p) LZ4_HASH64K_FUNCTION(A32(p))\r
-int LZ4_compress64kCtx(void** ctx,\r
+static inline int LZ4_compress64kCtx(void** ctx,\r
const char* source,\r
char* dest,\r
- int isize)\r
+ int isize,\r
+ int maxOutputSize)\r
{\r
#if HEAPMODE\r
struct refTables *srt = (struct refTables *) (*ctx);\r
#define matchlimit (iend - LASTLITERALS)\r
\r
BYTE* op = (BYTE*) dest;\r
+ BYTE* const oend = op + maxOutputSize;\r
\r
int len, length;\r
const int skipStrength = SKIPSTRENGTH;\r
\r
forwardH = LZ4_HASH64K_VALUE(forwardIp);\r
ref = base + HashTable[h];\r
- HashTable[h] = ip - base;\r
+ HashTable[h] = (U16)(ip - base);\r
\r
} while (A32(ref) != A32(ip));\r
\r
while ((ip>anchor) && (ref>(BYTE*)source) && (ip[-1]==ref[-1])) { ip--; ref--; }\r
\r
// Encode Literal length\r
- length = ip - anchor;\r
+ length = (int)(ip - anchor);\r
token = op++;\r
+ if unlikely(op + length + (2 + 1 + LASTLITERALS) + (length>>8) >= oend) return 0; // Check output limit\r
+#ifdef _MSC_VER\r
+ if (length>=(int)RUN_MASK) \r
+ { \r
+ int len = length-RUN_MASK; \r
+ *token=(RUN_MASK<<ML_BITS); \r
+ if (len>254)\r
+ {\r
+ do { *op++ = 255; len -= 255; } while (len>254);\r
+ *op++ = (BYTE)len; \r
+ memcpy(op, anchor, length);\r
+ op += length;\r
+ goto _next_match;\r
+ }\r
+ else\r
+ *op++ = (BYTE)len; \r
+ }\r
+ else *token = (length<<ML_BITS);\r
+#else\r
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *op++ = 255; *op++ = (BYTE)len; }\r
else *token = (length<<ML_BITS);\r
+#endif\r
\r
// Copy Literals\r
LZ4_BLINDCOPY(anchor, op, length);\r
\r
_next_match:\r
// Encode Offset\r
- LZ4_WRITE_LITTLEENDIAN_16(op,ip-ref);\r
+ LZ4_WRITE_LITTLEENDIAN_16(op,(U16)(ip-ref));\r
\r
// Start Counting\r
ip+=MINMATCH; ref+=MINMATCH; // MinMatch verified\r
_endCount:\r
\r
// Encode MatchLength\r
- len = (ip - anchor);\r
+ len = (int)(ip - anchor);\r
+ if unlikely(op + (1 + LASTLITERALS) + (len>>8) >= oend) return 0; // Check output limit\r
if (len>=(int)ML_MASK) { *token+=ML_MASK; len-=ML_MASK; for(; len > 509 ; len-=510) { *op++ = 255; *op++ = 255; } if (len > 254) { len-=255; *op++ = 255; } *op++ = (BYTE)len; }\r
else *token += len;\r
\r
if (ip > mflimit) { anchor = ip; break; }\r
\r
// Fill table\r
- HashTable[LZ4_HASH64K_VALUE(ip-2)] = ip - 2 - base;\r
+ HashTable[LZ4_HASH64K_VALUE(ip-2)] = (U16)(ip - 2 - base);\r
\r
// Test next position\r
ref = base + HashTable[LZ4_HASH64K_VALUE(ip)];\r
- HashTable[LZ4_HASH64K_VALUE(ip)] = ip - base;\r
+ HashTable[LZ4_HASH64K_VALUE(ip)] = (U16)(ip - base);\r
if (A32(ref) == A32(ip)) { token = op++; *token=0; goto _next_match; }\r
\r
// Prepare next loop\r
_last_literals:\r
// Encode Last Literals\r
{\r
- int lastRun = iend - anchor;\r
- if ((LZ4_COMPRESSMIN>0) && (((op - (BYTE*)dest) + lastRun + 1 + ((lastRun-15)/255)) > isize - LZ4_COMPRESSMIN)) return 0;\r
+ int lastRun = (int)(iend - anchor);\r
+ if (((char*)op - dest) + lastRun + 1 + ((lastRun)>>8) >= maxOutputSize) return 0;\r
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }\r
else *op++ = (lastRun<<ML_BITS);\r
memcpy(op, anchor, iend - anchor);\r
}\r
\r
\r
-\r
-int LZ4_compress(const char* source,\r
- char* dest,\r
- int isize)\r
+int LZ4_compress_limitedOutput(const char* source, \r
+ char* dest, \r
+ int isize, \r
+ int maxOutputSize)\r
{\r
#if HEAPMODE\r
void* ctx = malloc(sizeof(struct refTables));\r
int result;\r
if (isize < LZ4_64KLIMIT)\r
- result = LZ4_compress64kCtx(&ctx, source, dest, isize);\r
- else result = LZ4_compressCtx(&ctx, source, dest, isize);\r
+ result = LZ4_compress64kCtx(&ctx, source, dest, isize, maxOutputSize);\r
+ else result = LZ4_compressCtx(&ctx, source, dest, isize, maxOutputSize);\r
free(ctx);\r
return result;\r
#else\r
- if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize);\r
- return LZ4_compressCtx(NULL, source, dest, isize);\r
+ if (isize < (int)LZ4_64KLIMIT) return LZ4_compress64kCtx(NULL, source, dest, isize, maxOutputSize);\r
+ return LZ4_compressCtx(NULL, source, dest, isize, maxOutputSize);\r
#endif\r
}\r
\r
\r
+int LZ4_compress(const char* source,\r
+ char* dest,\r
+ int isize)\r
+{\r
+ return LZ4_compress_limitedOutput(source, dest, isize, LZ4_compressBound(isize));\r
+}\r
+\r
+\r
\r
\r
//****************************\r
\r
/*\r
LZ4_compress() :\r
+ Compresses 'isize' bytes from 'source' into 'dest'.\r
+ Destination buffer must be already allocated,\r
+ and must be sized to handle worst cases situations (input data not compressible)\r
+ Worst case size evaluation is provided by macro LZ4_compressBound()\r
+\r
isize : is the input size. Max supported value is ~1.9GB\r
return : the number of bytes written in buffer dest\r
- or 0 if the compression fails (if LZ4_COMPRESSMIN is set)\r
- note : destination buffer must be already allocated.\r
- destination buffer must be sized to handle worst cases situations (input data not compressible)\r
- worst case size evaluation is provided by function LZ4_compressBound()\r
+\r
\r
LZ4_uncompress() :\r
osize : is the output size, therefore the original size\r
return : the number of bytes read in the source buffer\r
If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction\r
This function never writes beyond dest + osize, and is therefore protected against malicious data packets\r
- note : destination buffer must be already allocated\r
+ note : destination buffer must be already allocated.\r
+ its size must be a minimum of 'osize' bytes.\r
*/\r
\r
\r
// Advanced Functions\r
//****************************\r
\r
-int LZ4_compressBound(int isize);\r
+#define LZ4_compressBound(isize) (isize + (isize/255) + 16)\r
\r
/*\r
LZ4_compressBound() :\r
*/\r
\r
\r
+int LZ4_compress_limitedOutput (const char* source, char* dest, int isize, int maxOutputSize);\r
+\r
+/*\r
+LZ4_compress_limitedOutput() :\r
+ Compress 'isize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.\r
+ If it cannot achieve it, compression will stop, and result of the function will be zero.\r
+ This function never writes outside of provided output buffer.\r
+\r
+ isize : is the input size. Max supported value is ~1.9GB\r
+ maxOutputSize : is the size of the destination buffer (which must be already allocated)\r
+ return : the number of bytes written in buffer 'dest'\r
+ or 0 if the compression fails\r
+*/\r
+\r
+\r
int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);\r
\r
/*\r
*/\r
\r
\r
-int LZ4_compressCtx(void** ctx, const char* source, char* dest, int isize);\r
-int LZ4_compress64kCtx(void** ctx, const char* source, char* dest, int isize);\r
-\r
-/*\r
-LZ4_compressCtx() :\r
- This function explicitly handles the CTX memory structure.\r
- It avoids allocating/deallocating memory between each call, improving performance when malloc is heavily invoked.\r
- This function is only useful when memory is allocated into the heap (HASH_LOG value beyond STACK_LIMIT)\r
- Performance difference will be noticeable only when repetitively calling the compression function over many small segments.\r
- Note : by default, memory is allocated into the stack, therefore "malloc" is not invoked.\r
-LZ4_compress64kCtx() :\r
- Same as LZ4_compressCtx(), but specific to small inputs (<64KB).\r
- isize *Must* be <64KB, otherwise the output will be corrupted.\r
-\r
- On first call : provide a *ctx=NULL; It will be automatically allocated.\r
- On next calls : reuse the same ctx pointer.\r
- Use different pointers for different threads when doing multi-threading.\r
-\r
-*/\r
-\r
-\r
#if defined (__cplusplus)\r
}\r
#endif\r
\r
#ifdef _MSC_VER\r
#define inline __forceinline // Visual is not C99, but supports some kind of inline\r
+#include <intrin.h> // For Visual 2005\r
+# if LZ4_ARCH64 // 64-bit\r
+# pragma intrinsic(_BitScanForward64) // For Visual 2005\r
+# pragma intrinsic(_BitScanReverse64) // For Visual 2005\r
+# else\r
+# pragma intrinsic(_BitScanForward) // For Visual 2005\r
+# pragma intrinsic(_BitScanReverse) // For Visual 2005\r
+# endif\r
#endif\r
\r
#ifdef _MSC_VER // Visual Studio\r
-#define bswap16(x) _byteswap_ushort(x)\r
+#define lz4_bswap16(x) _byteswap_ushort(x)\r
#else\r
-#define bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8)))\r
+#define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8)))\r
#endif\r
\r
\r
#endif\r
\r
#if defined(LZ4_BIG_ENDIAN)\r
-#define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = bswap16(v); d = (s) - v; }\r
-#define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = bswap16(v); A16(p) = v; p+=2; }\r
+#define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = lz4_bswap16(v); d = (s) - v; }\r
+#define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = lz4_bswap16(v); A16(p) = v; p+=2; }\r
#else // Little Endian\r
#define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); }\r
#define LZ4_WRITE_LITTLEENDIAN_16(p,v) { A16(p) = v; p+=2; }\r
if ((ipt<matchlimit) && (*reft == *ipt)) ipt++;\r
_endCount:\r
\r
- if (ipt-ip > ml) { ml = ipt-ip; *matchpos = ref; }\r
+ if (ipt-ip > ml) { ml = (int)(ipt-ip); *matchpos = ref; }\r
}\r
ref = GETNEXT(ref);\r
}\r
INITBASE(base,hc4->base);\r
const BYTE* ref;\r
int nbAttempts = MAX_NB_ATTEMPTS;\r
- int delta = ip-startLimit;\r
+ int delta = (int)(ip-startLimit);\r
\r
// First Match\r
LZ4HC_Insert(hc4, ip);\r
\r
if ((ipt-startt) > longest)\r
{\r
- longest = ipt-startt;\r
+ longest = (int)(ipt-startt);\r
*matchpos = reft;\r
*startpos = startt;\r
}\r
BYTE* token;\r
\r
// Encode Literal length\r
- length = *ip - *anchor;\r
+ length = (int)(*ip - *anchor);\r
token = (*op)++;\r
if (length>=(int)RUN_MASK) { *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *(*op)++ = 255; *(*op)++ = (BYTE)len; } \r
else *token = (length<<ML_BITS);\r
LZ4_BLINDCOPY(*anchor, *op, length);\r
\r
// Encode Offset\r
- LZ4_WRITE_LITTLEENDIAN_16(*op,*ip-ref);\r
+ LZ4_WRITE_LITTLEENDIAN_16(*op,(U16)(*ip-ref));\r
\r
// Encode MatchLength\r
len = (int)(ml-MINMATCH);\r
int correction;\r
int new_ml = ml;\r
if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;\r
- if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = start2 - ip + ml2 - MINMATCH;\r
- correction = new_ml - (start2 - ip);\r
+ if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH;\r
+ correction = new_ml - (int)(start2 - ip);\r
if (correction > 0)\r
{\r
start2 += correction;\r
{\r
int correction;\r
if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;\r
- if (ip+ml > start2 + ml2 - MINMATCH) ml = start2 - ip + ml2 - MINMATCH;\r
- correction = ml - (start2 - ip);\r
+ if (ip+ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH;\r
+ correction = ml - (int)(start2 - ip);\r
if (correction > 0)\r
{\r
start2 += correction;\r
}\r
else\r
{\r
- ml = start2 - ip;\r
+ ml = (int)(start2 - ip);\r
}\r
}\r
// Now, encode 2 sequences\r
{\r
if (start2 < ip+ml)\r
{\r
- int correction = (ip+ml) - start2;\r
+ int correction = (int)(ip+ml - start2);\r
start2 += correction;\r
ref2 += correction;\r
ml2 -= correction;\r
{\r
int correction;\r
if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;\r
- if (ip + ml > start2 + ml2 - MINMATCH) ml = start2 - ip + ml2 - MINMATCH;\r
- correction = ml - (start2 - ip);\r
+ if (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH;\r
+ correction = ml - (int)(start2 - ip);\r
if (correction > 0)\r
{\r
start2 += correction;\r
}\r
else\r
{\r
- ml = start2 - ip;\r
+ ml = (int)(start2 - ip);\r
}\r
}\r
LZ4_encodeSequence(&ip, &op, &anchor, ml, ref);\r
\r
// Encode Last Literals\r
{\r
- int lastRun = iend - anchor;\r
+ int lastRun = (int)(iend - anchor);\r
if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; } \r
else *op++ = (lastRun<<ML_BITS);\r
memcpy(op, anchor, iend - anchor);\r
projects / profile / ivi / eet.git / commitdiff