summaryrefslogtreecommitdiffstats
path: root/hostTools/lzma/decompress
diff options
context:
space:
mode:
Diffstat (limited to 'hostTools/lzma/decompress')
-rw-r--r--hostTools/lzma/decompress/7z.h16
-rw-r--r--hostTools/lzma/decompress/7zlzma.c57
-rw-r--r--hostTools/lzma/decompress/AriBitCoder.h51
-rw-r--r--hostTools/lzma/decompress/BitTreeCoder.h160
-rw-r--r--hostTools/lzma/decompress/IInOutStreams.c38
-rw-r--r--hostTools/lzma/decompress/IInOutStreams.h62
-rw-r--r--hostTools/lzma/decompress/LZMA.h83
-rw-r--r--hostTools/lzma/decompress/LZMADecoder.c398
-rw-r--r--hostTools/lzma/decompress/LZMADecoder.h60
-rw-r--r--hostTools/lzma/decompress/LenCoder.h75
-rw-r--r--hostTools/lzma/decompress/LiteralCoder.h146
-rw-r--r--hostTools/lzma/decompress/Makefile6
-rw-r--r--hostTools/lzma/decompress/Portable.h59
-rw-r--r--hostTools/lzma/decompress/RCDefs.h43
-rw-r--r--hostTools/lzma/decompress/RangeCoder.h56
-rw-r--r--hostTools/lzma/decompress/WindowOut.h47
-rw-r--r--hostTools/lzma/decompress/vxTypesOld.h289
17 files changed, 1646 insertions, 0 deletions
diff --git a/hostTools/lzma/decompress/7z.h b/hostTools/lzma/decompress/7z.h
new file mode 100644
index 0000000..ca8ea7f
--- /dev/null
+++ b/hostTools/lzma/decompress/7z.h
@@ -0,0 +1,16 @@
+#ifndef __7Z_H
+#define __7Z_H
+
+#if defined __cplusplus
+extern "C"
+{
+#endif
+
+int decompress_lzma_7z(unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size);
+
+#if defined __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/hostTools/lzma/decompress/7zlzma.c b/hostTools/lzma/decompress/7zlzma.c
new file mode 100644
index 0000000..f45d6c2
--- /dev/null
+++ b/hostTools/lzma/decompress/7zlzma.c
@@ -0,0 +1,57 @@
+#include "7z.h"
+
+#ifdef _HOST_TOOL
+#include "stdio.h"
+#endif
+
+#include "LZMADecoder.h"
+
+
+static LzmaDecoder cc;
+ISequentialInStream in_stream;
+ISequentialOutStream out_stream;
+int decompress_lzma_7z( unsigned char* in_data,
+ unsigned in_size,
+ unsigned char* out_data,
+ unsigned out_size) {
+// LzmaDecoder cc;
+ int RC;
+ UINT64 in_size_l = in_size;
+ UINT64 out_size_l = out_size;
+
+
+ InStreamInit(in_data, in_size);
+
+ OutStreamInit((char *)out_data, out_size);
+
+ LzmaDecoderConstructor(&cc);
+
+ if ((RC = LzmaDecoderReadCoderProperties(&cc)) != S_OK)
+ {
+ return RC;
+ }
+
+ if (LzmaDecoderCode(&cc, &in_size_l, &out_size_l) != S_OK)
+ {
+ return -2;
+ }
+
+ if (out_stream.size != out_size)
+ {
+ return -3;
+ }
+
+ if ( out_stream.overflow )
+ {
+ return -4;
+ }
+
+ return 0;
+}
+
+//BRCM modification
+#ifdef __KERNEL__
+EXPORT_SYMBOL(decompress_lzma_7z);
+#endif
+
+
diff --git a/hostTools/lzma/decompress/AriBitCoder.h b/hostTools/lzma/decompress/AriBitCoder.h
new file mode 100644
index 0000000..cedc189
--- /dev/null
+++ b/hostTools/lzma/decompress/AriBitCoder.h
@@ -0,0 +1,51 @@
+#ifndef __COMPRESSION_BITCODER_H
+#define __COMPRESSION_BITCODER_H
+
+#include "RangeCoder.h"
+
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+
+#define kNumMoveReducingBits 2
+
+
+typedef UINT32 CBitDecoder;
+
+INLINE void BitDecoderInit(CBitDecoder *bitDecoder)
+ {
+ *bitDecoder = kBitModelTotal / 2;
+ }
+
+#if 0
+UINT32 BitDecode(ISequentialInStream *in_stream, CBitDecoder *bitDecoder, CRangeDecoder *aRangeDecoder);
+#else
+INLINE UINT32 BitDecode(ISequentialInStream *in_stream, CBitDecoder *bitDecoder, CRangeDecoder *aRangeDecoder)
+ {
+ UINT32 aNewBound = (aRangeDecoder->m_Range >> kNumBitModelTotalBits) * (*bitDecoder);
+ if (aRangeDecoder->m_Code < aNewBound)
+ {
+ aRangeDecoder->m_Range = aNewBound;
+ *bitDecoder += (kBitModelTotal - *bitDecoder) >> kNumMoveBits;
+ if (aRangeDecoder->m_Range < kTopValue)
+ {
+ aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | InStreamReadByte(in_stream);
+ aRangeDecoder->m_Range <<= 8;
+ }
+ return 0;
+ }
+ else
+ {
+ aRangeDecoder->m_Range -= aNewBound;
+ aRangeDecoder->m_Code -= aNewBound;
+ *bitDecoder -= (*bitDecoder) >> kNumMoveBits;
+ if (aRangeDecoder->m_Range < kTopValue)
+ {
+ aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | InStreamReadByte(in_stream);
+ aRangeDecoder->m_Range <<= 8;
+ }
+ return 1;
+ }
+ }
+#endif
+
+#endif
diff --git a/hostTools/lzma/decompress/BitTreeCoder.h b/hostTools/lzma/decompress/BitTreeCoder.h
new file mode 100644
index 0000000..8c663e6
--- /dev/null
+++ b/hostTools/lzma/decompress/BitTreeCoder.h
@@ -0,0 +1,160 @@
+#ifndef __BITTREECODER_H
+#define __BITTREECODER_H
+
+#include "AriBitCoder.h"
+#include "RCDefs.h"
+
+//BRCM modification start
+#ifdef _HOST_TOOL
+#include "stdio.h"
+#include "stdlib.h"
+#include "malloc.h"
+#endif
+
+#ifdef _CFE_
+#include "lib_malloc.h"
+#include "lib_printf.h"
+#define malloc(x) KMALLOC(x, 0)
+#endif
+
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#define printf printk
+//#define malloc(x) kmalloc(x,GFP_KERNEL)
+#define malloc(x) vmalloc(x)
+#define free(x) vfree(x)
+#endif
+//BRCM modification end
+
+//////////////////////////
+// CBitTreeDecoder
+
+typedef struct CBitTreeDecoder
+{
+ UINT32 m_NumBitLevels;
+ CBitDecoder *m_Models;
+} CBitTreeDecoder;
+
+// ~CBitTreeDecoder() { free(m_Models); }
+INLINE void BitTreeDecoderInit(CBitTreeDecoder *bitTreeDecoder, UINT32 aNumBitLevels)
+ {
+ int i;
+ bitTreeDecoder->m_NumBitLevels = aNumBitLevels;
+ bitTreeDecoder->m_Models = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << bitTreeDecoder->m_NumBitLevels));
+ //BRCM modification
+ //printf("malloc in BitTreeDecoderInit=%d\n",sizeof(CBitDecoder) * (1 << bitTreeDecoder->m_NumBitLevels));
+ if (!bitTreeDecoder->m_Models) {
+ printf("Error in allocating memory for bitTreeDecoder!\n");
+ return;
+ }
+ for(i = 1; i < (1 << aNumBitLevels); i++)
+ BitDecoderInit(&bitTreeDecoder->m_Models[i]);
+ }
+INLINE UINT32 BitTreeDecode(ISequentialInStream *in_stream, CBitTreeDecoder *bitTreeDecoder, CRangeDecoder *aRangeDecoder)
+ {
+ UINT32 aModelIndex = 1;
+ UINT32 aRange = aRangeDecoder->m_Range;
+ UINT32 aCode = aRangeDecoder->m_Code;
+ UINT32 aBitIndex;
+ for(aBitIndex = bitTreeDecoder->m_NumBitLevels; aBitIndex > 0; aBitIndex--)
+ {
+ RC_GETBIT(kNumMoveBits, bitTreeDecoder->m_Models[aModelIndex], aModelIndex)
+ }
+ aRangeDecoder->m_Range = aRange;
+ aRangeDecoder->m_Code = aCode;
+ return aModelIndex - (1 << bitTreeDecoder->m_NumBitLevels);
+ }
+
+
+////////////////////////////////
+// CReverseBitTreeDecoder2
+
+typedef struct CReverseBitTreeDecoder2
+{
+ UINT32 m_NumBitLevels;
+ CBitDecoder *m_Models;
+} CReverseBitTreeDecoder2;
+
+// CReverseBitTreeDecoder2(): m_Models(0) { }
+// ~CReverseBitTreeDecoder2() { free(m_Models); }
+INLINE BOOL ReverseBitTreeDecoder2Create(CReverseBitTreeDecoder2 *reverseBitTreeDecoder2, UINT32 aNumBitLevels)
+ {
+ reverseBitTreeDecoder2->m_NumBitLevels = aNumBitLevels;
+ reverseBitTreeDecoder2->m_Models = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder2->m_NumBitLevels));
+ //printf("malloc in ReverseBitTreeDecoder2Create=%d\n",sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder2->m_NumBitLevels));
+ if (!reverseBitTreeDecoder2->m_Models) {
+ printf("Error in allocating memory for reverseBitTreeDecoder2!\n");
+ return 0;
+ }
+ return (reverseBitTreeDecoder2->m_Models != 0);
+ }
+INLINE void ReverseBitTreeDecoder2Init(CReverseBitTreeDecoder2 *reverseBitTreeDecoder2)
+ {
+ UINT32 aNumModels = 1 << reverseBitTreeDecoder2->m_NumBitLevels;
+ UINT32 i;
+ for(i = 1; i < aNumModels; i++)
+ BitDecoderInit(&reverseBitTreeDecoder2->m_Models[i]);
+ }
+INLINE UINT32 ReverseBitTreeDecoder2Decode(ISequentialInStream *in_stream, CReverseBitTreeDecoder2 *reverseBitTreeDecoder2, CRangeDecoder *aRangeDecoder)
+ {
+ UINT32 aModelIndex = 1;
+ UINT32 aSymbol = 0;
+ UINT32 aRange = aRangeDecoder->m_Range;
+ UINT32 aCode = aRangeDecoder->m_Code;
+ UINT32 aBitIndex;
+ for(aBitIndex = 0; aBitIndex < reverseBitTreeDecoder2->m_NumBitLevels; aBitIndex++)
+ {
+ RC_GETBIT2(kNumMoveBits, reverseBitTreeDecoder2->m_Models[aModelIndex], aModelIndex, ; , aSymbol |= (1 << aBitIndex))
+ }
+ aRangeDecoder->m_Range = aRange;
+ aRangeDecoder->m_Code = aCode;
+ return aSymbol;
+ }
+
+
+////////////////////////////
+// CReverseBitTreeDecoder
+
+typedef struct CReverseBitTreeDecoder
+{
+ UINT32 m_NumBitLevels;
+ CBitDecoder *m_Models;
+} CReverseBitTreeDecoder;
+
+// CReverseBitTreeDecoder(): m_Models(0) { }
+// ~CReverseBitTreeDecoder() { free(m_Models); }
+INLINE void ReverseBitTreeDecoderInit(CReverseBitTreeDecoder *reverseBitTreeDecoder, UINT32 aNumBitLevels)
+ {
+ int i;
+ reverseBitTreeDecoder->m_NumBitLevels = aNumBitLevels;
+ reverseBitTreeDecoder->m_Models = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder->m_NumBitLevels));
+ //printf("malloc in ReverseBitTreeDecoderInit=%d\n",sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder->m_NumBitLevels));
+ if (!reverseBitTreeDecoder->m_Models) {
+ printf("Error in allocating memory for reverseBitTreeDecoder!\n");
+ return;
+ }
+ for(i = 1; i < (1 << reverseBitTreeDecoder->m_NumBitLevels); i++)
+ BitDecoderInit(&reverseBitTreeDecoder->m_Models[i]);
+ }
+
+INLINE UINT32 ReverseBitTreeDecoderDecode(ISequentialInStream *in_stream, CReverseBitTreeDecoder *reverseBitTreeDecoder, CRangeDecoder *aRangeDecoder)
+ {
+ UINT32 aModelIndex = 1;
+ UINT32 aSymbol = 0;
+ UINT32 aRange = aRangeDecoder->m_Range;
+ UINT32 aCode = aRangeDecoder->m_Code;
+ UINT32 aBitIndex;
+ for(aBitIndex = 0; aBitIndex < reverseBitTreeDecoder->m_NumBitLevels; aBitIndex++)
+ {
+ RC_GETBIT2(kNumMoveBits, reverseBitTreeDecoder->m_Models[aModelIndex], aModelIndex, ; , aSymbol |= (1 << aBitIndex))
+ }
+ aRangeDecoder->m_Range = aRange;
+ aRangeDecoder->m_Code = aCode;
+ return aSymbol;
+ }
+
+
+
+#endif
diff --git a/hostTools/lzma/decompress/IInOutStreams.c b/hostTools/lzma/decompress/IInOutStreams.c
new file mode 100644
index 0000000..789c4ae
--- /dev/null
+++ b/hostTools/lzma/decompress/IInOutStreams.c
@@ -0,0 +1,38 @@
+#include "IInOutStreams.h"
+// BRCM modification
+static void *lib_memcpy(void *dest,const void *src,size_t cnt);
+static void *lib_memcpy(void *dest,const void *src,size_t cnt)
+{
+ unsigned char *d;
+ const unsigned char *s;
+
+ d = (unsigned char *) dest;
+ s = (const unsigned char *) src;
+
+ while (cnt) {
+ *d++ = *s++;
+ cnt--;
+ }
+
+ return dest;
+}
+
+HRESULT InStreamRead(void *aData, UINT32 aSize, UINT32* aProcessedSize) {
+ if (aSize > in_stream.remainingBytes)
+ aSize = in_stream.remainingBytes;
+ *aProcessedSize = aSize;
+ lib_memcpy(aData, in_stream.data, aSize); // brcm modification
+ in_stream.remainingBytes -= aSize;
+ in_stream.data += aSize;
+ return S_OK;
+ }
+
+#if 0
+BYTE InStreamReadByte()
+ {
+ if (in_stream.remainingBytes == 0)
+ return 0x0;
+ in_stream.remainingBytes--;
+ return (BYTE) *in_stream.data++;
+ }
+#endif
diff --git a/hostTools/lzma/decompress/IInOutStreams.h b/hostTools/lzma/decompress/IInOutStreams.h
new file mode 100644
index 0000000..69abf39
--- /dev/null
+++ b/hostTools/lzma/decompress/IInOutStreams.h
@@ -0,0 +1,62 @@
+#ifndef __IINOUTSTREAMS_H
+#define __IINOUTSTREAMS_H
+
+#include "Portable.h"
+
+typedef struct ISequentialInStream
+{
+ unsigned char* data;
+ unsigned remainingBytes;
+} ISequentialInStream;
+
+extern ISequentialInStream in_stream;
+
+INLINE void InStreamInit(unsigned char * Adata, unsigned Asize)
+ {
+ in_stream.data = Adata;
+ in_stream.remainingBytes = Asize;
+ }
+
+HRESULT InStreamRead(void *aData, UINT32 aSize, UINT32* aProcessedSize);
+
+#if 0
+BYTE InStreamReadByte();
+#else
+INLINE BYTE InStreamReadByte(ISequentialInStream *in_stream)
+ {
+ if (in_stream->remainingBytes == 0)
+ return 0x0;
+ in_stream->remainingBytes--;
+ return (BYTE) *in_stream->data++;
+ }
+#endif
+
+
+
+typedef struct ISequentialOutStream
+{
+ char* data;
+ unsigned size;
+ BOOL overflow;
+ unsigned total;
+} ISequentialOutStream;
+
+extern ISequentialOutStream out_stream;
+
+#define OutStreamInit(Adata, Asize) \
+{ \
+ out_stream.data = Adata; \
+ out_stream.size = Asize; \
+ out_stream.overflow = FALSE; \
+ out_stream.total = 0; \
+}
+
+#define OutStreamSizeSet(newsize) \
+ { \
+ out_stream.total = newsize; \
+ if (out_stream.total > out_stream.size) \
+ out_stream.overflow = TRUE; \
+ }
+
+
+#endif
diff --git a/hostTools/lzma/decompress/LZMA.h b/hostTools/lzma/decompress/LZMA.h
new file mode 100644
index 0000000..368328c
--- /dev/null
+++ b/hostTools/lzma/decompress/LZMA.h
@@ -0,0 +1,83 @@
+#include "LenCoder.h"
+
+#ifndef __LZMA_H
+#define __LZMA_H
+
+
+#define kNumRepDistances 4
+
+#define kNumStates 12
+
+static const BYTE kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
+static const BYTE kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
+static const BYTE kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
+static const BYTE kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
+
+typedef BYTE CState;
+
+INLINE void CStateInit(CState *m_Index)
+ { *m_Index = 0; }
+INLINE void CStateUpdateChar(CState *m_Index)
+ { *m_Index = kLiteralNextStates[*m_Index]; }
+INLINE void CStateUpdateMatch(CState *m_Index)
+ { *m_Index = kMatchNextStates[*m_Index]; }
+INLINE void CStateUpdateRep(CState *m_Index)
+ { *m_Index = kRepNextStates[*m_Index]; }
+INLINE void CStateUpdateShortRep(CState *m_Index)
+ { *m_Index = kShortRepNextStates[*m_Index]; }
+
+
+#define kNumPosSlotBits 6
+#define kDicLogSizeMax 28
+#define kDistTableSizeMax 56
+
+//extern UINT32 kDistStart[kDistTableSizeMax];
+static const BYTE kDistDirectBits[kDistTableSizeMax] =
+{
+ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
+ 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19,
+ 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26
+};
+
+#define kNumLenToPosStates 4
+INLINE UINT32 GetLenToPosState(UINT32 aLen)
+{
+ aLen -= 2;
+ if (aLen < kNumLenToPosStates)
+ return aLen;
+ return kNumLenToPosStates - 1;
+}
+
+#define kMatchMinLen 2
+
+#define kMatchMaxLen (kMatchMinLen + kNumSymbolsTotal - 1)
+
+#define kNumAlignBits 4
+#define kAlignTableSize 16
+#define kAlignMask 15
+
+#define kStartPosModelIndex 4
+#define kEndPosModelIndex 14
+#define kNumPosModels 10
+
+#define kNumFullDistances (1 << (kEndPosModelIndex / 2))
+
+
+#define kMainChoiceLiteralIndex 0
+#define kMainChoiceMatchIndex 1
+
+#define kMatchChoiceDistanceIndex0
+#define kMatchChoiceRepetitionIndex 1
+
+#define kNumMoveBitsForMainChoice 5
+#define kNumMoveBitsForPosCoders 5
+
+#define kNumMoveBitsForAlignCoders 5
+
+#define kNumMoveBitsForPosSlotCoder 5
+
+#define kNumLitPosStatesBitsEncodingMax 4
+#define kNumLitContextBitsMax 8
+
+
+#endif
diff --git a/hostTools/lzma/decompress/LZMADecoder.c b/hostTools/lzma/decompress/LZMADecoder.c
new file mode 100644
index 0000000..fe6d86d
--- /dev/null
+++ b/hostTools/lzma/decompress/LZMADecoder.c
@@ -0,0 +1,398 @@
+#include "Portable.h"
+#ifdef _HOST_TOOL
+#include "stdio.h"
+#endif
+#include "LZMADecoder.h"
+
+
+//#define RETURN_E_OUTOFMEMORY_IF_FALSE(x) { if (!(x)) return E_OUTOFMEMORY; }
+
+
+static UINT32 kDistStart[kDistTableSizeMax];
+struct WindowOut out_window;
+
+/*
+ * BRCM modification: free all the allocated buffer by malloc
+ *
+ */
+static void LzmaDecoderFreeBuffer(LzmaDecoder *lzmaDecoder)
+{
+ int i,aPosState;
+
+ //printf("free lzmaDecoder->m_LiteralDecoder\n");
+ free((&lzmaDecoder->m_LiteralDecoder)->m_Coders);
+
+ for (i = 0; i < kNumLenToPosStates; i++) {
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free((&lzmaDecoder->m_PosSlotDecoder[i])->m_Models);
+ }
+ // from LenDecoderInit(&lzmaDecoder->m_LenDecoder;
+ for (aPosState = 0; aPosState < (&lzmaDecoder->m_LenDecoder)->m_NumPosStates; aPosState++) {
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_LenDecoder)->m_LowCoder[aPosState])->m_Models );
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_LenDecoder)->m_MidCoder[aPosState])->m_Models );
+ }
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_LenDecoder)->m_HighCoder)->m_Models );
+
+
+ // from LenDecoderInit(&lzmaDecoder->m_RepMatchLenDecoder);
+ for (aPosState = 0; aPosState < (&lzmaDecoder->m_RepMatchLenDecoder)->m_NumPosStates; aPosState++) {
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_RepMatchLenDecoder)->m_LowCoder[aPosState])->m_Models );
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_RepMatchLenDecoder)->m_MidCoder[aPosState])->m_Models );
+ }
+ //printf("free lzmaDecoder->m_PosSlotDecoder\n");
+ free( (&(&lzmaDecoder->m_RepMatchLenDecoder)->m_HighCoder)->m_Models );
+
+
+ //printf("free lzmaDecoder->m_PosAlignDecoder\n");
+ free((&lzmaDecoder->m_PosAlignDecoder)->m_Models);
+
+ for(i = 0; i < kNumPosModels; i++) {
+ //printf("free lzmaDecoder->m_PosDecoders\n");
+ free((&lzmaDecoder->m_PosDecoders[i])->m_Models);
+ }
+
+}
+
+HRESULT LzmaDecoderSetDictionarySize(
+ LzmaDecoder *lzmaDecoder,
+ UINT32 aDictionarySize)
+{
+ if (aDictionarySize > (1 << kDicLogSizeMax))
+ return E_INVALIDARG;
+
+// UINT32 aWindowReservSize = MyMax(aDictionarySize, UINT32(1 << 21));
+
+ if (lzmaDecoder->m_DictionarySize != aDictionarySize)
+ {
+ lzmaDecoder->m_DictionarySize = aDictionarySize;
+ }
+ return S_OK;
+}
+
+HRESULT LzmaDecoderSetLiteralProperties(
+ LzmaDecoder *lzmaDecoder,
+ UINT32 aLiteralPosStateBits,
+ UINT32 aLiteralContextBits)
+{
+ if (aLiteralPosStateBits > 8)
+ return E_INVALIDARG;
+ if (aLiteralContextBits > 8)
+ return E_INVALIDARG;
+ LitDecoderCreate(&lzmaDecoder->m_LiteralDecoder, aLiteralPosStateBits, aLiteralContextBits);
+ return S_OK;
+}
+
+HRESULT LzmaDecoderSetPosBitsProperties(
+ LzmaDecoder *lzmaDecoder,
+ UINT32 aNumPosStateBits)
+{
+ UINT32 aNumPosStates;
+ if (aNumPosStateBits > (UINT32) kNumPosStatesBitsMax)
+ return E_INVALIDARG;
+ aNumPosStates = 1 << aNumPosStateBits;
+ LenDecoderCreate(&lzmaDecoder->m_LenDecoder, aNumPosStates);
+ LenDecoderCreate(&lzmaDecoder->m_RepMatchLenDecoder, aNumPosStates);
+ lzmaDecoder->m_PosStateMask = aNumPosStates - 1;
+ return S_OK;
+}
+
+
+void LzmaDecoderConstructor(LzmaDecoder *lzmaDecoder)
+{
+ lzmaDecoder->m_DictionarySize = ((UINT32)-1);
+ LzmaDecoderCreate(lzmaDecoder);
+}
+
+HRESULT LzmaDecoderCreate(LzmaDecoder *lzmaDecoder)
+{
+ int i;
+ for(i = 0; i < kNumPosModels; i++)
+ {
+ if (!(ReverseBitTreeDecoder2Create(&lzmaDecoder->m_PosDecoders[i],kDistDirectBits[kStartPosModelIndex + i])))
+ return E_OUTOFMEMORY;;
+ }
+ return S_OK;
+}
+
+
+HRESULT LzmaDecoderInit(LzmaDecoder *lzmaDecoder)
+{
+ int i;
+ UINT32 j;
+
+ RangeDecoderInit(&in_stream, &lzmaDecoder->m_RangeDecoder);
+
+ OutWindowInit();
+
+ for(i = 0; i < kNumStates; i++)
+ {
+ for (j = 0; j <= lzmaDecoder->m_PosStateMask; j++)
+ {
+ BitDecoderInit(&lzmaDecoder->m_MainChoiceDecoders[i][j]);
+ BitDecoderInit(&lzmaDecoder->m_MatchRepShortChoiceDecoders[i][j]);
+ }
+ BitDecoderInit(&lzmaDecoder->m_MatchChoiceDecoders[i]);
+ BitDecoderInit(&lzmaDecoder->m_MatchRepChoiceDecoders[i]);
+ BitDecoderInit(&lzmaDecoder->m_MatchRep1ChoiceDecoders[i]);
+ BitDecoderInit(&lzmaDecoder->m_MatchRep2ChoiceDecoders[i]);
+ }
+
+ LitDecoderInit(&lzmaDecoder->m_LiteralDecoder);
+
+ for (i = 0; i < (int) kNumLenToPosStates; i++)
+ BitTreeDecoderInit(&lzmaDecoder->m_PosSlotDecoder[i],kNumPosSlotBits);
+
+ for(i = 0; i < kNumPosModels; i++)
+ ReverseBitTreeDecoder2Init(&lzmaDecoder->m_PosDecoders[i]);
+
+ LenDecoderInit(&lzmaDecoder->m_LenDecoder);
+ LenDecoderInit(&lzmaDecoder->m_RepMatchLenDecoder);
+
+ ReverseBitTreeDecoderInit(&lzmaDecoder->m_PosAlignDecoder, kNumAlignBits);
+ return S_OK;
+
+}
+
+HRESULT LzmaDecoderCodeReal(
+ LzmaDecoder *lzmaDecoder,
+ UINT64 *anInSize,
+ UINT64 *anOutSize)
+{
+ BOOL aPeviousIsMatch = FALSE;
+ BYTE aPreviousByte = 0;
+ UINT32 aRepDistances[kNumRepDistances];
+ int i;
+ UINT64 aNowPos64 = 0;
+ UINT64 aSize = *anOutSize;
+ ISequentialInStream my_in_stream;
+// WindowOut out_window;
+ CState aState;
+
+ CStateInit(&aState);
+
+ if (anOutSize == NULL)
+ {
+ printf("CodeReal: invalid argument %x\n", (UINT32) anOutSize );
+ return E_INVALIDARG;
+ }
+
+
+ LzmaDecoderInit(lzmaDecoder);
+
+ my_in_stream.data = in_stream.data;
+ my_in_stream.remainingBytes = in_stream.remainingBytes;
+
+ for(i = 0 ; i < (int) kNumRepDistances; i++)
+ aRepDistances[i] = 0;
+
+ //while(aNowPos64 < aSize)
+ while(my_in_stream.remainingBytes > 0)
+ {
+ UINT64 aNext = MyMin(aNowPos64 + (1 << 18), aSize);
+ while(aNowPos64 < aNext)
+ {
+ UINT32 aPosState = (UINT32)(aNowPos64) & lzmaDecoder->m_PosStateMask;
+ if (BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MainChoiceDecoders[aState][aPosState],
+ &lzmaDecoder->m_RangeDecoder) == (UINT32) kMainChoiceLiteralIndex)
+ {
+ CStateUpdateChar(&aState);
+ if(aPeviousIsMatch)
+ {
+ BYTE aMatchByte = OutWindowGetOneByte(0 - aRepDistances[0] - 1);
+ aPreviousByte = LitDecodeWithMatchByte(&my_in_stream,
+ &lzmaDecoder->m_LiteralDecoder,
+ &lzmaDecoder->m_RangeDecoder,
+ (UINT32)(aNowPos64),
+ aPreviousByte,
+ aMatchByte);
+ aPeviousIsMatch = FALSE;
+ }
+ else
+ aPreviousByte = LitDecodeNormal(&my_in_stream,
+ &lzmaDecoder->m_LiteralDecoder,
+ &lzmaDecoder->m_RangeDecoder,
+ (UINT32)(aNowPos64),
+ aPreviousByte);
+ OutWindowPutOneByte(aPreviousByte);
+ aNowPos64++;
+ }
+ else
+ {
+ UINT32 aDistance, aLen;
+ aPeviousIsMatch = TRUE;
+ if(BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MatchChoiceDecoders[aState],
+ &lzmaDecoder->m_RangeDecoder) == (UINT32) kMatchChoiceRepetitionIndex)
+ {
+ if(BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MatchRepChoiceDecoders[aState],
+ &lzmaDecoder->m_RangeDecoder) == 0)
+ {
+ if(BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MatchRepShortChoiceDecoders[aState][aPosState],
+ &lzmaDecoder->m_RangeDecoder) == 0)
+ {
+ CStateUpdateShortRep(&aState);
+ aPreviousByte = OutWindowGetOneByte(0 - aRepDistances[0] - 1);
+ OutWindowPutOneByte(aPreviousByte);
+ aNowPos64++;
+ continue;
+ }
+ aDistance = aRepDistances[0];
+ }
+ else
+ {
+ if(BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MatchRep1ChoiceDecoders[aState],
+ &lzmaDecoder->m_RangeDecoder) == 0)
+ {
+ aDistance = aRepDistances[1];
+ aRepDistances[1] = aRepDistances[0];
+ }
+ else
+ {
+ if (BitDecode(&my_in_stream,
+ &lzmaDecoder->m_MatchRep2ChoiceDecoders[aState],
+ &lzmaDecoder->m_RangeDecoder) == 0)
+ {
+ aDistance = aRepDistances[2];
+ }
+ else
+ {
+ aDistance = aRepDistances[3];
+ aRepDistances[3] = aRepDistances[2];
+ }
+ aRepDistances[2] = aRepDistances[1];
+ aRepDistances[1] = aRepDistances[0];
+ }
+ aRepDistances[0] = aDistance;
+ }
+ aLen = LenDecode(&my_in_stream,
+ &lzmaDecoder->m_RepMatchLenDecoder,
+ &lzmaDecoder->m_RangeDecoder,
+ aPosState) + kMatchMinLen;
+ CStateUpdateRep(&aState);
+ }
+ else
+ {
+ UINT32 aPosSlot;
+ aLen = kMatchMinLen + LenDecode(&my_in_stream,
+ &lzmaDecoder->m_LenDecoder,
+ &lzmaDecoder->m_RangeDecoder,
+ aPosState);
+ CStateUpdateMatch(&aState);
+ aPosSlot = BitTreeDecode(&my_in_stream,
+ &lzmaDecoder->m_PosSlotDecoder[GetLenToPosState(aLen)],
+ &lzmaDecoder->m_RangeDecoder);
+ if (aPosSlot >= (UINT32) kStartPosModelIndex)
+ {
+ aDistance = kDistStart[aPosSlot];
+ if (aPosSlot < (UINT32) kEndPosModelIndex)
+ aDistance += ReverseBitTreeDecoder2Decode(&my_in_stream,
+ &lzmaDecoder->m_PosDecoders[aPosSlot - kStartPosModelIndex],
+ &lzmaDecoder->m_RangeDecoder);
+ else
+ {
+ aDistance += (RangeDecodeDirectBits(&my_in_stream,
+ &lzmaDecoder->m_RangeDecoder,
+ kDistDirectBits[aPosSlot] - kNumAlignBits) << kNumAlignBits);
+ aDistance += ReverseBitTreeDecoderDecode(&my_in_stream,
+ &lzmaDecoder->m_PosAlignDecoder,
+ &lzmaDecoder->m_RangeDecoder);
+ }
+ }
+ else
+ aDistance = aPosSlot;
+
+
+ aRepDistances[3] = aRepDistances[2];
+ aRepDistances[2] = aRepDistances[1];
+ aRepDistances[1] = aRepDistances[0];
+
+ aRepDistances[0] = aDistance;
+ }
+ if (aDistance >= aNowPos64)
+ {
+ printf("CodeReal: invalid data\n" );
+ return E_INVALIDDATA;
+ }
+ OutWindowCopyBackBlock(aDistance, aLen);
+ aNowPos64 += aLen;
+ aPreviousByte = OutWindowGetOneByte(0 - 1);
+ }
+ }
+ }
+
+ //BRCM modification
+ LzmaDecoderFreeBuffer(lzmaDecoder);
+
+ OutWindowFlush();
+ return S_OK;
+}
+
+HRESULT LzmaDecoderCode(
+ LzmaDecoder *lzmaDecoder,
+ UINT64 *anInSize,
+ UINT64 *anOutSize)
+{
+
+ UINT32 aStartValue = 0;
+ int i;
+
+ for (i = 0; i < kDistTableSizeMax; i++)
+ {
+ kDistStart[i] = aStartValue;
+ aStartValue += (1 << kDistDirectBits[i]);
+ }
+ return LzmaDecoderCodeReal(
+ lzmaDecoder,
+ anInSize,
+ anOutSize);
+}
+
+HRESULT LzmaDecoderReadCoderProperties(LzmaDecoder *lzmaDecoder)
+{
+ UINT32 aNumPosStateBits;
+ UINT32 aLiteralPosStateBits;
+ UINT32 aLiteralContextBits;
+ UINT32 aDictionarySize;
+ BYTE aRemainder;
+ UINT32 aProcessesedSize;
+
+ BYTE aByte;
+ RETURN_IF_NOT_S_OK(InStreamRead(&aByte,
+ sizeof(aByte),
+ &aProcessesedSize));
+
+ if (aProcessesedSize != sizeof(aByte))
+ return E_INVALIDARG;
+
+ aLiteralContextBits = aByte % 9;
+ aRemainder = aByte / 9;
+ aLiteralPosStateBits = aRemainder % 5;
+ aNumPosStateBits = aRemainder / 5;
+
+ RETURN_IF_NOT_S_OK(InStreamRead(&aDictionarySize,
+ sizeof(aDictionarySize),
+ &aProcessesedSize));
+
+ if (aProcessesedSize != sizeof(aDictionarySize))
+ return E_INVALIDARG;
+
+ RETURN_IF_NOT_S_OK( LzmaDecoderSetDictionarySize(lzmaDecoder,
+ aDictionarySize) );
+ RETURN_IF_NOT_S_OK( LzmaDecoderSetLiteralProperties(lzmaDecoder,
+ aLiteralPosStateBits,
+ aLiteralContextBits) );
+ RETURN_IF_NOT_S_OK( LzmaDecoderSetPosBitsProperties(lzmaDecoder,
+ aNumPosStateBits) );
+
+ return S_OK;
+}
+
diff --git a/hostTools/lzma/decompress/LZMADecoder.h b/hostTools/lzma/decompress/LZMADecoder.h
new file mode 100644
index 0000000..76fa536
--- /dev/null
+++ b/hostTools/lzma/decompress/LZMADecoder.h
@@ -0,0 +1,60 @@
+#ifndef __LZARITHMETIC_DECODER_H
+#define __LZARITHMETIC_DECODER_H
+
+#include "WindowOut.h"
+#include "LZMA.h"
+#include "LenCoder.h"
+#include "LiteralCoder.h"
+
+
+typedef struct LzmaDecoder
+{
+ CRangeDecoder m_RangeDecoder;
+
+ CBitDecoder m_MainChoiceDecoders[kNumStates][kNumPosStatesMax];
+ CBitDecoder m_MatchChoiceDecoders[kNumStates];
+ CBitDecoder m_MatchRepChoiceDecoders[kNumStates];
+ CBitDecoder m_MatchRep1ChoiceDecoders[kNumStates];
+ CBitDecoder m_MatchRep2ChoiceDecoders[kNumStates];
+ CBitDecoder m_MatchRepShortChoiceDecoders[kNumStates][kNumPosStatesMax];
+
+ CBitTreeDecoder m_PosSlotDecoder[kNumLenToPosStates];
+
+ CReverseBitTreeDecoder2 m_PosDecoders[kNumPosModels];
+ CReverseBitTreeDecoder m_PosAlignDecoder;
+
+ LenDecoder m_LenDecoder;
+ LenDecoder m_RepMatchLenDecoder;
+
+ LitDecoder m_LiteralDecoder;
+
+ UINT32 m_DictionarySize;
+
+ UINT32 m_PosStateMask;
+} LzmaDecoder;
+
+ HRESULT LzmaDecoderCreate(LzmaDecoder *lzmaDecoder);
+
+ HRESULT LzmaDecoderInit(LzmaDecoder *lzmaDecoder);
+
+//static inline HRESULT LzmaDecoderFlush() { return OutWindowFlush(); }
+
+ HRESULT LzmaDecoderCodeReal(
+ LzmaDecoder *lzmaDecoder,
+// ISequentialInStream *in_stream,
+ UINT64 *anInSize,
+// WindowOut *out_window,
+ UINT64 *anOutSize);
+
+
+ void LzmaDecoderConstructor( LzmaDecoder *lzmaDecoder );
+
+ HRESULT LzmaDecoderCode( LzmaDecoder *lzmaDecoder, UINT64 *anInSize, UINT64 *anOutSize);
+ HRESULT LzmaDecoderReadCoderProperties(LzmaDecoder *lzmaDecoder );
+
+ HRESULT LzmaDecoderSetDictionarySize(LzmaDecoder *lzmaDecoder, UINT32 aDictionarySize);
+ HRESULT LzmaDecoderSetLiteralProperties(LzmaDecoder *lzmaDecoder, UINT32 aLiteralPosStateBits, UINT32 aLiteralContextBits);
+ HRESULT LzmaDecoderSetPosBitsProperties(LzmaDecoder *lzmaDecoder, UINT32 aNumPosStateBits);
+
+
+#endif
diff --git a/hostTools/lzma/decompress/LenCoder.h b/hostTools/lzma/decompress/LenCoder.h
new file mode 100644
index 0000000..40552b8
--- /dev/null
+++ b/hostTools/lzma/decompress/LenCoder.h
@@ -0,0 +1,75 @@
+#ifndef __LENCODER_H
+#define __LENCODER_H
+
+#include "BitTreeCoder.h"
+
+
+#define kNumPosStatesBitsMax 4
+#define kNumPosStatesMax 16
+
+
+#define kNumPosStatesBitsEncodingMax 4
+#define kNumPosStatesEncodingMax 16
+
+
+//#define kNumMoveBits 5
+
+#define kNumLenBits 3
+#define kNumLowSymbols (1 << kNumLenBits)
+
+#define kNumMidBits 3
+#define kNumMidSymbols (1 << kNumMidBits)
+
+#define kNumHighBits 8
+
+#define kNumSymbolsTotal (kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits))
+
+typedef struct LenDecoder
+{
+ CBitDecoder m_Choice;
+ CBitDecoder m_Choice2;
+ CBitTreeDecoder m_LowCoder[kNumPosStatesMax];
+ CBitTreeDecoder m_MidCoder[kNumPosStatesMax];
+ CBitTreeDecoder m_HighCoder;
+ UINT32 m_NumPosStates;
+} LenDecoder;
+
+INLINE void LenDecoderCreate(LenDecoder *lenCoder, UINT32 aNumPosStates)
+ {
+ lenCoder->m_NumPosStates = aNumPosStates;
+ }
+
+INLINE void LenDecoderInit(LenDecoder *lenCoder)
+ {
+ UINT32 aPosState;
+ BitDecoderInit(&lenCoder->m_Choice);
+ for (aPosState = 0; aPosState < lenCoder->m_NumPosStates; aPosState++)
+ {
+ BitTreeDecoderInit(&lenCoder->m_LowCoder[aPosState],kNumLenBits);
+ BitTreeDecoderInit(&lenCoder->m_MidCoder[aPosState],kNumMidBits);
+ }
+ BitTreeDecoderInit(&lenCoder->m_HighCoder,kNumHighBits);
+ BitDecoderInit(&lenCoder->m_Choice2);
+ }
+
+INLINE UINT32 LenDecode(ISequentialInStream *in_stream, LenDecoder *lenCoder, CRangeDecoder *aRangeDecoder, UINT32 aPosState)
+ {
+ if(BitDecode(in_stream, &lenCoder->m_Choice, aRangeDecoder) == 0)
+ return BitTreeDecode(in_stream, &lenCoder->m_LowCoder[aPosState],aRangeDecoder);
+ else
+ {
+ UINT32 aSymbol = kNumLowSymbols;
+ if(BitDecode(in_stream, &lenCoder->m_Choice2, aRangeDecoder) == 0)
+ aSymbol += BitTreeDecode(in_stream, &lenCoder->m_MidCoder[aPosState],aRangeDecoder);
+ else
+ {
+ aSymbol += kNumMidSymbols;
+ aSymbol += BitTreeDecode(in_stream, &lenCoder->m_HighCoder,aRangeDecoder);
+ }
+ return aSymbol;
+ }
+ }
+
+
+
+#endif
diff --git a/hostTools/lzma/decompress/LiteralCoder.h b/hostTools/lzma/decompress/LiteralCoder.h
new file mode 100644
index 0000000..2b1670d
--- /dev/null
+++ b/hostTools/lzma/decompress/LiteralCoder.h
@@ -0,0 +1,146 @@
+#ifndef __LITERALCODER_H
+#define __LITERALCODER_H
+
+#include "AriBitCoder.h"
+#include "RCDefs.h"
+
+//BRCM modification start
+#ifdef _HOST_TOOL
+#include "stdio.h"
+#include "malloc.h"
+#endif
+
+#ifdef _CFE_
+#include "lib_malloc.h"
+#include "lib_printf.h"
+#define malloc(x) KMALLOC(x, 0)
+#define free(x) KFREE(x)
+#endif
+
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#define printf printk
+//#define malloc(x) kmalloc(x,GFP_KERNEL)
+#define malloc(x) vmalloc(x)
+#define free(x) vfree(x)
+#endif
+//BRCM modification end
+
+//#define kNumMoveBits 5
+
+typedef struct LitDecoder2
+{
+ CBitDecoder m_Decoders[3][1 << 8];
+} LitDecoder2;
+
+
+INLINE void LitDecoder2Init(LitDecoder2 *litDecoder2)
+ {
+ int i, j;
+ for (i = 0; i < 3; i++)
+ for (j = 1; j < (1 << 8); j++)
+ BitDecoderInit(&litDecoder2->m_Decoders[i][j]);
+ }
+
+INLINE BYTE LitDecoder2DecodeNormal(ISequentialInStream *in_stream, LitDecoder2 *litDecoder2, CRangeDecoder *aRangeDecoder)
+ {
+ UINT32 aSymbol = 1;
+ UINT32 aRange = aRangeDecoder->m_Range;
+ UINT32 aCode = aRangeDecoder->m_Code;
+ do
+ {
+ RC_GETBIT(kNumMoveBits, litDecoder2->m_Decoders[0][aSymbol], aSymbol)
+ }
+ while (aSymbol < 0x100);
+ aRangeDecoder->m_Range = aRange;
+ aRangeDecoder->m_Code = aCode;
+ return aSymbol;
+ }
+
+INLINE BYTE LitDecoder2DecodeWithMatchByte(ISequentialInStream *in_stream, LitDecoder2 *litDecoder2, CRangeDecoder *aRangeDecoder, BYTE aMatchByte)
+ {
+ UINT32 aSymbol = 1;
+ UINT32 aRange = aRangeDecoder->m_Range;
+ UINT32 aCode = aRangeDecoder->m_Code;
+ do
+ {
+ UINT32 aBit;
+ UINT32 aMatchBit = (aMatchByte >> 7) & 1;
+ aMatchByte <<= 1;
+ RC_GETBIT2(kNumMoveBits, litDecoder2->m_Decoders[1 + aMatchBit][aSymbol], aSymbol,
+ aBit = 0, aBit = 1)
+ if (aMatchBit != aBit)
+ {
+ while (aSymbol < 0x100)
+ {
+ RC_GETBIT(kNumMoveBits, litDecoder2->m_Decoders[0][aSymbol], aSymbol)
+ }
+ break;
+ }
+ }
+ while (aSymbol < 0x100);
+ aRangeDecoder->m_Range = aRange;
+ aRangeDecoder->m_Code = aCode;
+ return aSymbol;
+ }
+
+
+typedef struct LitDecoder
+{
+ LitDecoder2 *m_Coders;
+ UINT32 m_NumPrevBits;
+ UINT32 m_NumPosBits;
+ UINT32 m_PosMask;
+} LitDecoder;
+
+
+// LitDecoder(): m_Coders(0) {}
+// ~LitDecoder() { Free(); }
+
+/*
+INLINE void LitDecoderFree(LitDecoder *litDecoder)
+ {
+ free( (char *) litDecoder->m_Coders );
+ litDecoder->m_Coders = 0;
+ }
+*/
+
+INLINE void LitDecoderCreate(LitDecoder *litDecoder, UINT32 aNumPosBits, UINT32 aNumPrevBits)
+ {
+// LitDecoderFree(litDecoder);
+ UINT32 aNumStates;
+ litDecoder->m_NumPosBits = aNumPosBits;
+ litDecoder->m_PosMask = (1 << aNumPosBits) - 1;
+ litDecoder->m_NumPrevBits = aNumPrevBits;
+ aNumStates = 1 << (aNumPrevBits + aNumPosBits);
+ litDecoder->m_Coders = (LitDecoder2*) malloc( sizeof( LitDecoder2 ) * aNumStates );
+ //printf("malloc in LitDecoderCreate=%d\n",sizeof( LitDecoder2 ) * aNumStates);
+ if (litDecoder->m_Coders == 0)
+ printf( "Error allocating memory for LitDecoder m_Coders!\n" );
+ }
+
+INLINE void LitDecoderInit(LitDecoder *litDecoder)
+ {
+ UINT32 i;
+ UINT32 aNumStates = 1 << (litDecoder->m_NumPrevBits + litDecoder->m_NumPosBits);
+ for (i = 0; i < aNumStates; i++)
+ LitDecoder2Init(&litDecoder->m_Coders[i]);
+ }
+
+INLINE UINT32 LitDecoderGetState(LitDecoder *litDecoder, UINT32 aPos, BYTE aPrevByte)
+ {
+ return ((aPos & litDecoder->m_PosMask) << litDecoder->m_NumPrevBits) + (aPrevByte >> (8 - litDecoder->m_NumPrevBits));
+ }
+
+INLINE BYTE LitDecodeNormal(ISequentialInStream *in_stream, LitDecoder *litDecoder, CRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte)
+ {
+ return LitDecoder2DecodeNormal(in_stream, &litDecoder->m_Coders[LitDecoderGetState(litDecoder, aPos, aPrevByte)], aRangeDecoder);
+ }
+
+INLINE BYTE LitDecodeWithMatchByte(ISequentialInStream *in_stream, LitDecoder *litDecoder, CRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte, BYTE aMatchByte)
+ {
+ return LitDecoder2DecodeWithMatchByte(in_stream, &litDecoder->m_Coders[LitDecoderGetState(litDecoder, aPos, aPrevByte)], aRangeDecoder, aMatchByte);
+ }
+
+#endif
diff --git a/hostTools/lzma/decompress/Makefile b/hostTools/lzma/decompress/Makefile
new file mode 100644
index 0000000..e21ff1d
--- /dev/null
+++ b/hostTools/lzma/decompress/Makefile
@@ -0,0 +1,6 @@
+
+BSPOBJS += \
+ 7zlzma.o \
+ LZMADecoder.o \
+ IInOutStreams.o \
+
diff --git a/hostTools/lzma/decompress/Portable.h b/hostTools/lzma/decompress/Portable.h
new file mode 100644
index 0000000..698f30b
--- /dev/null
+++ b/hostTools/lzma/decompress/Portable.h
@@ -0,0 +1,59 @@
+#ifndef __PORTABLE_H
+#define __PORTABLE_H
+
+//BRCM modification
+#ifdef _HOST_TOOL
+#include <string.h>
+#endif
+
+#ifdef _CFE_
+#include <string.h>
+#endif
+
+#ifdef __KERNEL__
+#include <linux/string.h>
+#endif
+
+//bcm
+//#ifdef __GNUC__
+//#include <types/vxTypesOld.h>
+//#define INLINE static inline
+//#else
+typedef char INT8;
+typedef unsigned char UINT8;
+typedef short INT16;
+typedef unsigned short UINT16;
+typedef int INT32;
+typedef unsigned int UINT32;
+typedef int BOOL;
+#define INLINE static inline
+//#define INLINE static __inline__
+//#endif
+typedef long long INT64; // %%%% Changed from "long long"
+typedef unsigned long long UINT64; // %%%% Changed from "long long"
+
+typedef UINT8 BYTE;
+typedef UINT16 WORD;
+typedef UINT32 DWORD;
+
+typedef unsigned UINT_PTR;
+#define FALSE 0
+#define TRUE 1
+
+#define HRESULT int
+#define S_OK 0
+#define E_INVALIDARG -1
+#define E_OUTOFMEMORY -2
+#define E_FAIL -3
+#define E_INTERNAL_ERROR -4
+#define E_INVALIDDATA -5
+
+#define MyMin( a, b ) ( a < b ? a : b )
+
+#define MyMax( a, b ) ( a > b ? a : b )
+
+#define kNumMoveBits 5
+
+#define RETURN_IF_NOT_S_OK(x) { HRESULT __aResult_ = (x); if(__aResult_ != S_OK) return __aResult_; }
+
+#endif
diff --git a/hostTools/lzma/decompress/RCDefs.h b/hostTools/lzma/decompress/RCDefs.h
new file mode 100644
index 0000000..f260ab4
--- /dev/null
+++ b/hostTools/lzma/decompress/RCDefs.h
@@ -0,0 +1,43 @@
+#ifndef __RCDEFS_H
+#define __RCDEFS_H
+
+#include "AriBitCoder.h"
+
+/*
+#define RC_INIT_VAR \
+ UINT32 aRange = aRangeDecoder->m_Range; \
+ UINT32 aCode = aRangeDecoder->m_Code;
+
+#define RC_FLUSH_VAR \
+ aRangeDecoder->m_Range = aRange; \
+ aRangeDecoder->m_Code = aCode;
+*/
+
+
+#if 1
+#define RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, Action0, Action1) \
+ {UINT32 aNewBound = (aRange >> kNumBitModelTotalBits) * aProb; \
+ if (aCode < aNewBound) \
+ { \
+ Action0; \
+ aRange = aNewBound; \
+ aProb += (kBitModelTotal - aProb) >> aNumMoveBits; \
+ aModelIndex <<= 1; \
+ } \
+ else \
+ { \
+ Action1; \
+ aRange -= aNewBound; \
+ aCode -= aNewBound; \
+ aProb -= (aProb) >> aNumMoveBits; \
+ aModelIndex = (aModelIndex << 1) + 1; \
+ }} \
+ if (aRange < kTopValue) \
+ { \
+ aCode = (aCode << 8) | InStreamReadByte(in_stream); \
+ aRange <<= 8; }
+
+#define RC_GETBIT(aNumMoveBits, aProb, aModelIndex) RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, ; , ;)
+#endif
+
+#endif
diff --git a/hostTools/lzma/decompress/RangeCoder.h b/hostTools/lzma/decompress/RangeCoder.h
new file mode 100644
index 0000000..ae6f974
--- /dev/null
+++ b/hostTools/lzma/decompress/RangeCoder.h
@@ -0,0 +1,56 @@
+#ifndef __COMPRESSION_RANGECODER_H
+#define __COMPRESSION_RANGECODER_H
+
+#include "IInOutStreams.h"
+
+#define kNumTopBits 24
+#define kTopValue (1 << kNumTopBits)
+
+typedef struct CRangeDecoder
+{
+ UINT32 m_Range;
+ UINT32 m_Code;
+} CRangeDecoder;
+
+
+
+INLINE void RangeDecoderInit(
+ ISequentialInStream *in_stream,
+ CRangeDecoder *rangeDecoder)
+ {
+ int i;
+ rangeDecoder->m_Code = 0;
+ rangeDecoder->m_Range = (UINT32)(-1);
+ for(i = 0; i < 5; i++)
+ rangeDecoder->m_Code = (rangeDecoder->m_Code << 8) | InStreamReadByte(in_stream);
+ }
+
+INLINE UINT32 RangeDecodeDirectBits(
+ ISequentialInStream *in_stream,
+ CRangeDecoder *rangeDecoder,
+ UINT32 aNumTotalBits)
+ {
+ UINT32 aRange = rangeDecoder->m_Range;
+ UINT32 aCode = rangeDecoder->m_Code;
+ UINT32 aResult = 0;
+ UINT32 i;
+ for (i = aNumTotalBits; i > 0; i--)
+ {
+ UINT32 t;
+ aRange >>= 1;
+ t = (aCode - aRange) >> 31;
+ aCode -= aRange & (t - 1);
+ aResult = (aResult << 1) | (1 - t);
+
+ if (aRange < kTopValue)
+ {
+ aCode = (aCode << 8) | InStreamReadByte(in_stream);
+ aRange <<= 8;
+ }
+ }
+ rangeDecoder->m_Range = aRange;
+ rangeDecoder->m_Code = aCode;
+ return aResult;
+ }
+
+#endif
diff --git a/hostTools/lzma/decompress/WindowOut.h b/hostTools/lzma/decompress/WindowOut.h
new file mode 100644
index 0000000..d774cac
--- /dev/null
+++ b/hostTools/lzma/decompress/WindowOut.h
@@ -0,0 +1,47 @@
+#ifndef __STREAM_WINDOWOUT_H
+#define __STREAM_WINDOWOUT_H
+
+#include "IInOutStreams.h"
+
+typedef struct WindowOut
+{
+ BYTE *Buffer;
+ UINT32 Pos;
+} WindowOut;
+
+extern WindowOut out_window;
+
+#define OutWindowInit() \
+ { \
+ out_window.Buffer = (BYTE *) out_stream.data; \
+ out_window.Pos = 0; \
+ }
+
+#define OutWindowFlush() \
+ { \
+ OutStreamSizeSet( out_window.Pos ); \
+ }
+
+// BRCM modification
+INLINE void OutWindowCopyBackBlock(UINT32 aDistance, UINT32 aLen)
+ {
+ BYTE *p = out_window.Buffer + out_window.Pos;
+ UINT32 i;
+ aDistance++;
+ for(i = 0; i < aLen; i++)
+ p[i] = p[i - aDistance];
+ out_window.Pos += aLen;
+ }
+
+
+#define OutWindowPutOneByte(aByte) \
+ { \
+ out_window.Buffer[out_window.Pos++] = aByte; \
+ }
+
+#define OutWindowGetOneByte(anIndex) \
+ (out_window.Buffer[out_window.Pos + anIndex])
+
+
+
+#endif
diff --git a/hostTools/lzma/decompress/vxTypesOld.h b/hostTools/lzma/decompress/vxTypesOld.h
new file mode 100644
index 0000000..7ee57bf
--- /dev/null
+++ b/hostTools/lzma/decompress/vxTypesOld.h
@@ -0,0 +1,289 @@
+/* vxTypesOld.h - old VxWorks type definition header */
+
+/* Copyright 1984-1997 Wind River Systems, Inc. */
+
+/*
+modification history
+--------------------
+02c,15aug97,cym added simnt support.
+02d,26mar97,cdp added Thumb (ARM7TDMI_T) support.
+02c,28nov96,cdp added ARM support.
+02b,28sep95,ms removed "static __inline__" (SPR #4500)
+02b,12jul95,ism added simsolaris support
+02a,19mar95,dvs removed tron references.
+01z,01sep94,ism fixed comment as per SPR# 1512.
+01y,02dec93,pme added Am29K family support.
+01x,12jun93,rrr vxsim.
+02a,26may94,yao added PPC support.
+01w,09jun93,hdn added support for I80X86
+01v,12feb93,srh added C++ versions of FUNCPTR, et al.
+01u,13nov92,dnw added definition of VOID (SPR #1781)
+01t,02oct92,srh replaced conditional around volatile, const, and signed so
+ they won't be elided when __STDC__ is defined.
+ added __cplusplus to __STDC__ condition.
+01s,22sep92,rrr added support for c++
+01r,08sep92,smb made some additions for the MIPS.
+01q,07sep92,smb added __STDC__ and modes to maintain compatibility with 5.0
+01p,07jul92,rrr moved STACK_GROW and ENDIAN to vxArch.h
+01o,03jul92,smb changed name from vxTypes.h.
+01n,26may92,rrr the tree shuffle
+01m,25nov91,llk included sys/types.h.
+01l,04oct91,rrr passed through the ansification filter
+ -fixed #else and #endif
+ -removed TINY and UTINY
+ -changed VOID to void
+ -changed ASMLANGUAGE to _ASMLANGUAGE
+ -changed copyright notice
+01k,01oct91,jpb fixed MIPS conditional for undefined CPU_FAMILY.
+01j,20sep91,wmd conditionalized out defines for const, unsigned and volatile
+ for the MIPS architecture.
+01i,02aug91,ajm added support for MIPS_R3k.
+01h,15may91,gae added define for "signed" when not available for pre-ANSI.
+01g,29apr91,hdn added defines and macros for TRON architecture.
+01f,28apr91,del added defines of __volatile__ and __const__ if !_STDC_
+ && _GNUC__
+01f,24mar91,del added INSTR * define for I960.
+01e,28jan91,kdl added DBLFUNCPTR and FLTFUNCPTR.
+01d,25oct90,dnw changed void to void except when linting.
+01c,05oct90,shl added copyright notice.
+ made #endif ANSI style.
+01b,10aug90,dnw added VOIDFUNCPTR
+01a,29may90,del written.
+*/
+
+/*
+DESCRIPTION
+This header file contains a mixture of stuff.
+1) the old style typedefs (ie. POSIX now says they must end with _t).
+ These will be phased out gradually.
+2) a mechanism for getting rid of const warning which are produced by the
+ GNU C compiler. Hopefully, this will be removed in the future.
+3) macros that are so longer needed for vxWorks source code but maybe needed
+ by some customer applications and are therefore provided for backward
+ compatability.
+4) system III typedefs (used by netinet) which do not fit in anywhere else.
+
+*/
+
+#ifndef __INCvxTypesOldh
+#define __INCvxTypesOldh
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "sys/types.h"
+
+/* vxWorks types */
+
+typedef char INT8;
+typedef short INT16;
+typedef int INT32;
+
+typedef unsigned char UINT8;
+typedef unsigned short UINT16;
+typedef unsigned int UINT32;
+
+typedef unsigned char UCHAR;
+typedef unsigned short USHORT;
+typedef unsigned int UINT;
+typedef unsigned long ULONG;
+
+typedef int BOOL;
+typedef int STATUS;
+typedef int ARGINT;
+
+typedef void VOID;
+
+#ifdef __cplusplus
+typedef int (*FUNCPTR) (...); /* ptr to function returning int */
+typedef void (*VOIDFUNCPTR) (...); /* ptr to function returning void */
+typedef double (*DBLFUNCPTR) (...); /* ptr to function returning double*/
+typedef float (*FLTFUNCPTR) (...); /* ptr to function returning float */
+#else
+typedef int (*FUNCPTR) (); /* ptr to function returning int */
+typedef void (*VOIDFUNCPTR) (); /* ptr to function returning void */
+typedef double (*DBLFUNCPTR) (); /* ptr to function returning double*/
+typedef float (*FLTFUNCPTR) (); /* ptr to function returning float */
+#endif /* _cplusplus */
+
+
+/* This structure and the following definitions are needed to get rid
+ of const warning produced by the GNU C compiler.
+ */
+
+#if defined(__STDC__) || defined(__cplusplus)
+typedef union
+ {
+ long pm_int;
+ void *pm_v;
+ const void *pm_cv;
+ char *pm_c;
+ unsigned char *pm_uc;
+
+ signed char *pm_sc;
+ const char *pm_cc;
+ const unsigned char *pm_cuc;
+ const signed char *pm_csc;
+ short *pm_s;
+ ushort_t *pm_us;
+ const short *pm_cs;
+ const ushort_t *pm_cus;
+ int *pm_i;
+ uint_t *pm_ui;
+ const int *pm_ci;
+ const uint_t *pm_cui;
+ long *pm_l;
+ ulong_t *pm_ul;
+ const long *pm_cl;
+ const ulong_t *pm_cul;
+
+ int8_t *pm_i8;
+ uint8_t *pm_ui8;
+ const int8_t *pm_ci8;
+ const uint8_t *pm_cui8;
+ int16_t *pm_i16;
+ uint16_t *pm_ui16;
+ const int16_t *pm_ci16;
+ const uint16_t *pm_cui16;
+ int32_t *pm_i32;
+ uint32_t *pm_ui32;
+ const int32_t *pm_ci32;
+ const uint32_t *pm_cui32;
+#if _ARCH_MOVE_SIZE > 4
+ int64_t *pm_i64;
+ const int64_t *pm_ci64;
+#if _ARCH_MOVE_SIZE > 8
+ int128_t *pm_i128;
+ const int128_t *pm_ci128;
+#endif
+#endif
+ } pointer_mix_t;
+
+#define CHAR_FROM_CONST(x) (char *)(x)
+#define VOID_FROM_CONST(x) (void *)(x)
+
+#endif /* __STDC__ */
+
+#define STACK_DIR _ARCH_STACK_DIR
+#define ALIGN_MEMORY _ARCH_ALIGN_MEMORY
+#define ALIGN_STACK _ARCH_ALIGN_STACK
+#define ALIGN_REGS _ARCH_ALIGN_REGS
+
+#define NBBY 8 /* number of bits in a byte */
+
+/* modes - must match O_RDONLY/O_WRONLY/O_RDWR in ioLib.h! */
+
+#define READ 0
+#define WRITE 1
+#define UPDATE 2
+
+/* Select uses bit masks of file descriptors in longs.
+ * These macros manipulate such bit fields (the filesystem macros use chars).
+ * FD_SETSIZE may be defined by the user, but the default here
+ * should be >= maxFiles parameter in iosInit call found in usrConfig.c.
+ * If this define is changed, recompile the source, or else select() will
+ * not work.
+ */
+
+#ifndef FD_SETSIZE
+#define FD_SETSIZE 256
+#endif /* FD_SETSIZE */
+
+typedef long fd_mask;
+#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */
+#ifndef howmany
+#define howmany(x, y) ((unsigned int)(((x)+((y)-1)))/(unsigned int)(y))
+#endif /* howmany */
+
+typedef struct fd_set
+ {
+ fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+ } fd_set;
+
+#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+#define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
+
+
+/* system III typedefs (used by netinet) */
+
+typedef unsigned char u_char;
+typedef unsigned short u_short;
+typedef unsigned int u_int;
+typedef unsigned long u_long;
+typedef unsigned short ushort;
+
+
+/* historical definitions - now obsolete */
+
+typedef char TBOOL; /* obsolete */
+
+
+/* architecture dependent typedefs */
+
+#ifdef CPU_FAMILY
+
+#if CPU_FAMILY==MC680X0
+typedef unsigned short INSTR; /* word-aligned instructions */
+#endif /* CPU_FAMILY==MC680X0 */
+
+#if CPU_FAMILY==SPARC || CPU_FAMILY==MIPS || CPU_FAMILY==SIMSPARCSUNOS || CPU_FAMILY==SIMHPPA || CPU_FAMILY==SIMSPARCSOLARIS
+typedef unsigned long INSTR; /* 32 bit word-aligned instructions */
+#endif /* CPU_FAMILY==SPARC || CPU_FAMILY==MIPS || CPU_FAMILY==SIMSPARCSUNOS || CPU_FAMILY==SIMHPPA || CPU_FAMILY==SIMSPARCSOLARIS */
+
+#if CPU_FAMILY==I960
+typedef unsigned long INSTR; /* 32 bit word-aligned instructions */
+#endif /* CPU_FAMILY==I960 */
+
+#if CPU_FAMILY==I80X86 || CPU_FAMILY==SIMNT
+typedef unsigned char INSTR; /* char instructions */
+#endif /* CPU_FAMILY==I80X86 || CPU_FAMILY==SIMNT */
+
+#if CPU_FAMILY==AM29XXX
+typedef unsigned long INSTR; /* 32 bit word-aligned instructions */
+#endif /* CPU_FAMILY==AM29XXX */
+
+#if (CPU_FAMILY==PPC)
+typedef unsigned long INSTR; /* 32 bit word-aligned instructions */
+#endif /* (CPU_FAMILY==PPC) */
+
+#if CPU_FAMILY==ARM
+#if CPU==ARM7TDMI_T
+typedef unsigned short INSTR; /* 16 bit instructions */
+#else
+typedef unsigned long INSTR; /* 32 bit word-aligned instructions */
+#endif
+#endif /* CPU_FAMILY==ARM */
+
+#endif /* CPU_FAMILY */
+
+/* ANSI type qualifiers */
+
+#if !defined(__STDC__) && !defined(__cplusplus)
+
+#ifdef __GNUC__
+#define volatile __volatile__
+#define const __const__
+#define signed __signed__
+#else
+#if !(defined(CPU_FAMILY) && CPU_FAMILY==MIPS)
+#define volatile
+#define const
+#define signed
+#endif /* !(defined(CPU_FAMILY) && CPU_FAMILY==MIPS) */
+#endif /* __GNUC__ */
+
+#endif /* !defined(__STDC__) && !defined(__cplusplus) */
+
+#if CPU_FAMILY==MIPS
+#define CHAR_FROM_CONST(x) (char *)(x)
+#define VOID_FROM_CONST(x) (void *)(x)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __INCvxTypesOldh */
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-23 03:22:18 +0000