goat3d: fa5c52ea9d59 libs/openctm/liblzma/LzmaDec.c

848 SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)

849 {

850 SizeT outSize = *destLen;

851 SizeT inSize = *srcLen;

852 *srcLen = *destLen = 0;

853 for (;;)

854 {

855 SizeT inSizeCur = inSize, outSizeCur, dicPos;

856 ELzmaFinishMode curFinishMode;

857 SRes res;

858 if (p->dicPos == p->dicBufSize)

859 p->dicPos = 0;

860 dicPos = p->dicPos;

861 if (outSize > p->dicBufSize - dicPos)

862 {

863 outSizeCur = p->dicBufSize;

864 curFinishMode = LZMA_FINISH_ANY;

865 }

866 else

867 {

868 outSizeCur = dicPos + outSize;

869 curFinishMode = finishMode;

870 }

871

872 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);

873 src += inSizeCur;

874 inSize -= inSizeCur;

875 *srcLen += inSizeCur;

876 outSizeCur = p->dicPos - dicPos;

877 memcpy(dest, p->dic + dicPos, outSizeCur);

878 dest += outSizeCur;

879 outSize -= outSizeCur;

880 *destLen += outSizeCur;

881 if (res != 0)

882 return res;

883 if (outSizeCur == 0 || outSize == 0)

884 return SZ_OK;

885 }

886 }

887

888 void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)

889 {

890 alloc->Free(alloc, p->probs);

891 p->probs = 0;

892 }

893

894 static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)

895 {

896 alloc->Free(alloc, p->dic);

897 p->dic = 0;

898 }

899

900 void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)

901 {

902 LzmaDec_FreeProbs(p, alloc);

903 LzmaDec_FreeDict(p, alloc);

904 }

905

906 SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)

907 {

908 UInt32 dicSize;

909 Byte d;

910

911 if (size < LZMA_PROPS_SIZE)

912 return SZ_ERROR_UNSUPPORTED;

913 else

914 dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);

915

916 if (dicSize < LZMA_DIC_MIN)

917 dicSize = LZMA_DIC_MIN;

918 p->dicSize = dicSize;

919

920 d = data[0];

921 if (d >= (9 * 5 * 5))

922 return SZ_ERROR_UNSUPPORTED;

923

924 p->lc = d % 9;

925 d /= 9;

926 p->pb = d / 5;

927 p->lp = d % 5;

928

929 return SZ_OK;

930 }

931

932 static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)

933 {

934 UInt32 numProbs = LzmaProps_GetNumProbs(propNew);

935 if (p->probs == 0 || numProbs != p->numProbs)

936 {

937 LzmaDec_FreeProbs(p, alloc);

938 p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));

939 p->numProbs = numProbs;

940 if (p->probs == 0)

941 return SZ_ERROR_MEM;

942 }

943 return SZ_OK;

944 }

945

946 SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)

947 {

948 CLzmaProps propNew;

949 RINOK(LzmaProps_Decode(&propNew, props, propsSize));

950 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));

951 p->prop = propNew;

952 return SZ_OK;

953 }

954

955 SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)

956 {

957 CLzmaProps propNew;

958 SizeT dicBufSize;

959 RINOK(LzmaProps_Decode(&propNew, props, propsSize));

960 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));

961 dicBufSize = propNew.dicSize;

962 if (p->dic == 0 || dicBufSize != p->dicBufSize)

963 {

964 LzmaDec_FreeDict(p, alloc);

965 p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);

966 if (p->dic == 0)

967 {

968 LzmaDec_FreeProbs(p, alloc);

969 return SZ_ERROR_MEM;

970 }

971 }

972 p->dicBufSize = dicBufSize;

973 p->prop = propNew;

974 return SZ_OK;

975 }

976

977 SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,

978 const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,

979 ELzmaStatus *status, ISzAlloc *alloc)

980 {

981 CLzmaDec p;

982 SRes res;

983 SizeT inSize = *srcLen;

984 SizeT outSize = *destLen;

985 *srcLen = *destLen = 0;

986 if (inSize < RC_INIT_SIZE)

987 return SZ_ERROR_INPUT_EOF;

988

989 LzmaDec_Construct(&p);

990 res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);

991 if (res != 0)

992 return res;

993 p.dic = dest;

994 p.dicBufSize = outSize;

995

996 LzmaDec_Init(&p);

997

998 *srcLen = inSize;

999 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);

1000

1001 if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)

1002 res = SZ_ERROR_INPUT_EOF;

1003

1004 (*destLen) = p.dicPos;

1005 LzmaDec_FreeProbs(&p, alloc);

1006 return res;

1007 }