Пример #1
0
 public static void LZ4_freeStreamDecode(LZ4_streamDecode_t *LZ4_stream)
 {
     if (LZ4_stream != null)
     {
         Mem.Free(LZ4_stream);
     }
 }
Пример #2
0
 public static void LZ4_setStreamDecode(
     LZ4_streamDecode_t *lz4sd, byte *dictionary, int dictSize)
 {
     lz4sd->prefixSize   = (uint)dictSize;
     lz4sd->prefixEnd    = dictionary + dictSize;
     lz4sd->externalDict = null;
     lz4sd->extDictSize  = 0;
 }
Пример #3
0
        public static int LZ4_decompress_safe_continue(
            LZ4_streamDecode_t *lz4sd,
            byte *source,
            byte *dest,
            int compressedSize,
            int maxOutputSize)
        {
            int result;

            if (lz4sd->prefixEnd == dest)
            {
                result = LZ4_decompress_generic(
                    source,
                    dest,
                    compressedSize,
                    maxOutputSize,
                    endCondition_directive.endOnInputSize,
                    earlyEnd_directive.full,
                    0,
                    dict_directive.usingExtDict,
                    lz4sd->prefixEnd - lz4sd->prefixSize,
                    lz4sd->externalDict,
                    (int)lz4sd->extDictSize);
                if (result <= 0)
                {
                    return(result);
                }

                lz4sd->prefixSize += (uint)result;
                lz4sd->prefixEnd  += result;
            }
            else
            {
                lz4sd->extDictSize  = lz4sd->prefixSize;
                lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
                result = LZ4_decompress_generic(
                    source,
                    dest,
                    compressedSize,
                    maxOutputSize,
                    endCondition_directive.endOnInputSize,
                    earlyEnd_directive.full,
                    0,
                    dict_directive.usingExtDict,
                    dest,
                    lz4sd->externalDict,
                    (int)lz4sd->extDictSize);
                if (result <= 0)
                {
                    return(result);
                }

                lz4sd->prefixSize = (uint)result;
                lz4sd->prefixEnd  = dest + result;
            }

            return(result);
        }
        public static int LZ4_decompress_safe_continue(
            LZ4_streamDecode_t *LZ4_streamDecode, byte *source, byte *dest, int compressedSize,
            int maxOutputSize)
        {
            var lz4sd = LZ4_streamDecode;
            int result;

            if (lz4sd->prefixSize == 0)
            {
                /* The first call, no dictionary yet. */
                Assert(lz4sd->extDictSize == 0);
                result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
                if (result <= 0)
                {
                    return(result);
                }

                lz4sd->prefixSize = (size_t)result;
                lz4sd->prefixEnd  = (byte *)dest + result;
            }
            else if (lz4sd->prefixEnd == (byte *)dest)
            {
                /* They're rolling the current segment. */
                if (lz4sd->prefixSize >= 64 * KB - 1)
                {
                    result = LZ4_decompress_safe_withPrefix64k(
                        source, dest, compressedSize, maxOutputSize);
                }
                else if (lz4sd->extDictSize == 0)
                {
                    result = LZ4_decompress_safe_withSmallPrefix(
                        source, dest, compressedSize, maxOutputSize, lz4sd->prefixSize);
                }
                else
                {
                    result = LZ4_decompress_safe_doubleDict(
                        source, dest, compressedSize, maxOutputSize, lz4sd->prefixSize,
                        lz4sd->externalDict, lz4sd->extDictSize);
                }
                if (result <= 0)
                {
                    return(result);
                }

                lz4sd->prefixSize += (size_t)result;
                lz4sd->prefixEnd  += result;
            }
            else
            {
                /* The buffer wraps around, or they're switching to another buffer. */
                lz4sd->extDictSize  = lz4sd->prefixSize;
                lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
                result = LZ4_decompress_safe_forceExtDict(
                    source, dest, compressedSize, maxOutputSize,
                    lz4sd->externalDict, lz4sd->extDictSize);
                if (result <= 0)
                {
                    return(result);
                }

                lz4sd->prefixSize = (size_t)result;
                lz4sd->prefixEnd  = (byte *)dest + result;
            }

            return(result);
        }