Beispiel #1
0
 public void Lzma2Dec_Init()
 {
     mState         = Lzma2State.Control;
     mNeedInitDic   = true;
     mNeedInitState = true;
     mNeedInitProp  = true;
     mDecoder.LzmaDec_Init();
 }
Beispiel #2
0
            /*
             * finishMode:
             * It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
             * LZMA_FINISH_ANY - use smallest number of input bytes
             * LZMA_FINISH_END - read EndOfStream marker after decoding
             *
             * Returns:
             * SZ_OK
             *  status:
             *    LZMA_STATUS_FINISHED_WITH_MARK
             *    LZMA_STATUS_NOT_FINISHED
             *    LZMA_STATUS_NEEDS_MORE_INPUT
             * SZ_ERROR_DATA - Data error
             */

            public SRes Lzma2Dec_DecodeToDic(long dicLimit, P <byte> src, ref long srcLen, ELzmaFinishMode finishMode, out ELzmaStatus status)
            {
                long inSize = srcLen;

                srcLen = 0;
                status = ELzmaStatus.LZMA_STATUS_NOT_SPECIFIED;

                while (mState != Lzma2State.Finished)
                {
                    long dicPos = mDecoder.mDicPos;
                    if (mState == Lzma2State.Error)
                    {
                        return(SZ_ERROR_DATA);
                    }

                    if (dicPos == dicLimit && finishMode == ELzmaFinishMode.LZMA_FINISH_ANY)
                    {
                        status = ELzmaStatus.LZMA_STATUS_NOT_FINISHED;
                        return(SZ_OK);
                    }

                    if (mState != Lzma2State.Data && mState != Lzma2State.DataCont)
                    {
                        if (srcLen == inSize)
                        {
                            status = ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT;
                            return(SZ_OK);
                        }
                        srcLen++;
                        mState = Lzma2Dec_UpdateState(src[0]);
                        src++;
                        continue;
                    }

                    long            destSizeCur   = dicLimit - dicPos;
                    long            srcSizeCur    = inSize - srcLen;
                    ELzmaFinishMode curFinishMode = ELzmaFinishMode.LZMA_FINISH_ANY;

                    if (mUnpackSize <= destSizeCur)
                    {
                        destSizeCur   = mUnpackSize;
                        curFinishMode = ELzmaFinishMode.LZMA_FINISH_END;
                    }

                    if (IsUncompressedState())
                    {
                        if (srcLen == inSize)
                        {
                            status = ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT;
                            return(SZ_OK);
                        }

                        if (mState == Lzma2State.Data)
                        {
                            bool initDic = (mControl == LZMA2_CONTROL_COPY_RESET_DIC);
                            if (initDic)
                            {
                                mNeedInitProp = mNeedInitState = true;
                            }
                            else if (mNeedInitDic)
                            {
                                return(SZ_ERROR_DATA);
                            }

                            mNeedInitDic = false;
                            mDecoder.LzmaDec_InitDicAndState(initDic, false);
                        }

                        if (srcSizeCur > destSizeCur)
                        {
                            srcSizeCur = destSizeCur;
                        }

                        if (srcSizeCur == 0)
                        {
                            return(SZ_ERROR_DATA);
                        }

                        LzmaDec_UpdateWithUncompressed(mDecoder, src, srcSizeCur);

                        src         += srcSizeCur;
                        srcLen      += srcSizeCur;
                        mUnpackSize -= (uint)srcSizeCur;
                        mState       = (mUnpackSize == 0) ? Lzma2State.Control : Lzma2State.DataCont;
                    }
                    else
                    {
                        long outSizeProcessed;

                        if (mState == Lzma2State.Data)
                        {
                            int  mode      = GetLzmaMode();
                            bool initDic   = (mode == 3);
                            bool initState = (mode > 0);
                            if ((!initDic && mNeedInitDic) || (!initState && mNeedInitState))
                            {
                                return(SZ_ERROR_DATA);
                            }

                            mDecoder.LzmaDec_InitDicAndState(initDic, initState);
                            mNeedInitDic   = false;
                            mNeedInitState = false;
                            mState         = Lzma2State.DataCont;
                        }

                        if (srcSizeCur > mPackSize)
                        {
                            srcSizeCur = mPackSize;
                        }

                        SRes res = mDecoder.LzmaDec_DecodeToDic(dicPos + destSizeCur, src, ref srcSizeCur, curFinishMode, out status);

                        src       += srcSizeCur;
                        srcLen    += srcSizeCur;
                        mPackSize -= (uint)srcSizeCur;

                        outSizeProcessed = mDecoder.mDicPos - dicPos;
                        mUnpackSize     -= (uint)outSizeProcessed;

                        if (res != SZ_OK)
                        {
                            return(res);
                        }

                        if (status == ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT)
                        {
                            return(res);
                        }

                        if (srcSizeCur == 0 && outSizeProcessed == 0)
                        {
                            if (status != ELzmaStatus.LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK || mUnpackSize != 0 || mPackSize != 0)
                            {
                                return(SZ_ERROR_DATA);
                            }

                            mState = Lzma2State.Control;
                        }

                        if (status == ELzmaStatus.LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
                        {
                            status = ELzmaStatus.LZMA_STATUS_NOT_FINISHED;
                        }
                    }
                }

                status = ELzmaStatus.LZMA_STATUS_FINISHED_WITH_MARK;
                return(SZ_OK);
            }
Beispiel #3
0
 public void Lzma2Dec_Init()
 {
     mState = Lzma2State.Control;
     mNeedInitDic = true;
     mNeedInitState = true;
     mNeedInitProp = true;
     mDecoder.LzmaDec_Init();
 }
Beispiel #4
0
            /*
            finishMode:
              It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
              LZMA_FINISH_ANY - use smallest number of input bytes
              LZMA_FINISH_END - read EndOfStream marker after decoding

            Returns:
              SZ_OK
                status:
                  LZMA_STATUS_FINISHED_WITH_MARK
                  LZMA_STATUS_NOT_FINISHED
                  LZMA_STATUS_NEEDS_MORE_INPUT
              SZ_ERROR_DATA - Data error
            */
            public SRes Lzma2Dec_DecodeToDic(long dicLimit, P<byte> src, ref long srcLen, ELzmaFinishMode finishMode, out ELzmaStatus status)
            {
                long inSize = srcLen;
                srcLen = 0;
                status = ELzmaStatus.LZMA_STATUS_NOT_SPECIFIED;

                while (mState != Lzma2State.Finished)
                {
                    long dicPos = mDecoder.mDicPos;
                    if (mState == Lzma2State.Error)
                        return SZ_ERROR_DATA;

                    if (dicPos == dicLimit && finishMode == ELzmaFinishMode.LZMA_FINISH_ANY)
                    {
                        status = ELzmaStatus.LZMA_STATUS_NOT_FINISHED;
                        return SZ_OK;
                    }

                    if (mState != Lzma2State.Data && mState != Lzma2State.DataCont)
                    {
                        if (srcLen == inSize)
                        {
                            status = ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT;
                            return SZ_OK;
                        }
                        srcLen++;
                        mState = Lzma2Dec_UpdateState(src[0]);
                        src++;
                        continue;
                    }

                    long destSizeCur = dicLimit - dicPos;
                    long srcSizeCur = inSize - srcLen;
                    ELzmaFinishMode curFinishMode = ELzmaFinishMode.LZMA_FINISH_ANY;

                    if (mUnpackSize <= destSizeCur)
                    {
                        destSizeCur = mUnpackSize;
                        curFinishMode = ELzmaFinishMode.LZMA_FINISH_END;
                    }

                    if (IsUncompressedState())
                    {
                        if (srcLen == inSize)
                        {
                            status = ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT;
                            return SZ_OK;
                        }

                        if (mState == Lzma2State.Data)
                        {
                            bool initDic = (mControl == LZMA2_CONTROL_COPY_RESET_DIC);
                            if (initDic)
                                mNeedInitProp = mNeedInitState = true;
                            else if (mNeedInitDic)
                                return SZ_ERROR_DATA;

                            mNeedInitDic = false;
                            mDecoder.LzmaDec_InitDicAndState(initDic, false);
                        }

                        if (srcSizeCur > destSizeCur)
                            srcSizeCur = destSizeCur;

                        if (srcSizeCur == 0)
                            return SZ_ERROR_DATA;

                        LzmaDec_UpdateWithUncompressed(mDecoder, src, srcSizeCur);

                        src += srcSizeCur;
                        srcLen += srcSizeCur;
                        mUnpackSize -= (uint)srcSizeCur;
                        mState = (mUnpackSize == 0) ? Lzma2State.Control : Lzma2State.DataCont;
                    }
                    else
                    {
                        long outSizeProcessed;

                        if (mState == Lzma2State.Data)
                        {
                            int mode = GetLzmaMode();
                            bool initDic = (mode == 3);
                            bool initState = (mode > 0);
                            if ((!initDic && mNeedInitDic) || (!initState && mNeedInitState))
                                return SZ_ERROR_DATA;

                            mDecoder.LzmaDec_InitDicAndState(initDic, initState);
                            mNeedInitDic = false;
                            mNeedInitState = false;
                            mState = Lzma2State.DataCont;
                        }

                        if (srcSizeCur > mPackSize)
                            srcSizeCur = mPackSize;

                        SRes res = mDecoder.LzmaDec_DecodeToDic(dicPos + destSizeCur, src, ref srcSizeCur, curFinishMode, out status);

                        src += srcSizeCur;
                        srcLen += srcSizeCur;
                        mPackSize -= (uint)srcSizeCur;

                        outSizeProcessed = mDecoder.mDicPos - dicPos;
                        mUnpackSize -= (uint)outSizeProcessed;

                        if (res != SZ_OK)
                            return res;

                        if (status == ELzmaStatus.LZMA_STATUS_NEEDS_MORE_INPUT)
                            return res;

                        if (srcSizeCur == 0 && outSizeProcessed == 0)
                        {
                            if (status != ELzmaStatus.LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK || mUnpackSize != 0 || mPackSize != 0)
                                return SZ_ERROR_DATA;

                            mState = Lzma2State.Control;
                        }

                        if (status == ELzmaStatus.LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
                            status = ELzmaStatus.LZMA_STATUS_NOT_FINISHED;
                    }
                }

                status = ELzmaStatus.LZMA_STATUS_FINISHED_WITH_MARK;
                return SZ_OK;
            }