Author: areq Date: Wed Jun 15 20:36:40 2005 GMT Module: SOURCES Tag: HEAD ---- Log message: - better version by Christian Leber
---- Files affected: SOURCES: busybox-lzmacat.diff (1.1 -> 1.2) ---- Diffs: ================================================================ Index: SOURCES/busybox-lzmacat.diff diff -u SOURCES/busybox-lzmacat.diff:1.1 SOURCES/busybox-lzmacat.diff:1.2 --- SOURCES/busybox-lzmacat.diff:1.1 Sun Jun 5 16:49:24 2005 +++ SOURCES/busybox-lzmacat.diff Wed Jun 15 22:36:35 2005 @@ -1,39 +1,204 @@ -diff -urN busybox.snapshot/archival/Config.in busybox-lzmacat/archival/Config.in ---- busybox.snapshot/archival/Config.in 2005-05-03 21:43:40.000000000 +0200 -+++ busybox-lzmacat/archival/Config.in 2005-05-03 21:46:02.000000000 +0200 -@@ -121,6 +121,12 @@ - gzip is used to compress files. - It's probably the most widely used UNIX compression program. - -+config CONFIG_LZMACAT -+ bool "lzmacat" -+ default n -+ help -+ lzmacat decompresses a given file to STUOUT +--- busybox-20050614.orig/archival/libunarchive/lzmacat.c 1970-01-01 01:00:00.000000000 +0100 ++++ busybox-20050614/archival/lzmacat.c 2005-06-15 02:13:51.000000000 +0200 +@@ -0,0 +1,190 @@ ++/* ++ lzmacat.c + - config CONFIG_RPM2CPIO - bool "rpm2cpio" - default n -diff -urN busybox.snapshot/archival/Makefile.in busybox-lzmacat/archival/Makefile.in ---- busybox.snapshot/archival/Makefile.in 2005-05-03 21:43:40.000000000 +0200 -+++ busybox-lzmacat/archival/Makefile.in 2005-05-03 21:46:02.000000000 +0200 -@@ -32,6 +32,7 @@ - ARCHIVAL-$(CONFIG_DPKG_DEB) += dpkg_deb.o - ARCHIVAL-$(CONFIG_GUNZIP) += gunzip.o - ARCHIVAL-$(CONFIG_GZIP) += gzip.o -+ARCHIVAL-$(CONFIG_LZMACAT) += lzmacat.o - ARCHIVAL-$(CONFIG_RPM2CPIO) += rpm2cpio.o - ARCHIVAL-$(CONFIG_RPM) += rpm.o - ARCHIVAL-$(CONFIG_TAR) += tar.o -diff -urN busybox.snapshot/archival/libunarchive/LzmaDecode.c busybox-lzmacat/archival/libunarchive/LzmaDecode.c ---- busybox.snapshot/archival/libunarchive/LzmaDecode.c 1970-01-01 01:00:00.000000000 +0100 -+++ busybox-lzmacat/archival/libunarchive/LzmaDecode.c 2005-05-03 21:46:02.000000000 +0200 -@@ -0,0 +1,663 @@ ++ Copyright (C) 1999-2004 Igor Pavlov (2005-03-18)) ++ examplecode from the LZMA DSK ++ Copyright (C) 2005 Christian Leber ++ changed to lzmcacat functionality ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ ++ e-mail: [EMAIL PROTECTED] ++*/ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <unistd.h> ++ ++#include "busybox.h" ++#include "libunarchive/LzmaDecode.h" ++ ++#define _LZMA_READ_BUFFER_SIZE 0x10000 ++#define _LZMA_WRITE_BUFFER_SIZE 0x10000 ++ ++#ifdef _LZMA_IN_CB ++typedef struct _CBuffer ++{ ++ ILzmaInCallback InCallback; ++ unsigned char *Buffer; ++ FILE *fil; ++} CBuffer; ++ ++int LzmaReadCompressed(void *object, unsigned char **buffer, unsigned int *size) ++{ ++ CBuffer *bo = (CBuffer *)object; ++ /* try to read _LZMA_READ_SIZE bytes */ ++ *size = fread(bo->Buffer,1, ++ _LZMA_READ_BUFFER_SIZE,bo->fil); ++ *buffer = bo->Buffer; ++ return LZMA_RESULT_OK; ++} ++#endif ++ ++int lzmacat_main(int argc, char **argv) ++{ ++ FILE *inputHandle; ++ unsigned int outSize, outSizeProcessed, lzmaInternalSize; ++ void *lzmaInternalData; ++ unsigned char header[13]; ++ unsigned char prop0; ++ unsigned char *out_buffer; ++ int i, res; ++ int lc, lp, pb; ++ CBuffer bo; ++ UInt32 nowPos; ++ unsigned char *dictionary; ++ UInt32 dictionarySize = 0; ++ ++ if (argc != 2) { ++ fprintf(stderr, "lzmacat\n"); ++ fprintf(stderr, "Usage: lzmaDec file.lzma\n"); ++ return 1; ++ } ++ ++ inputHandle = fopen(argv[1], "rb"); ++ if (inputHandle == 0) { ++ fprintf(stderr, "Open input file errori\n"); ++ return 1; ++ } ++ ++ if (!fread(header, 1, sizeof(header),inputHandle)) { ++ fprintf(stderr, "Can't read header\n"); ++ return 1; ++ } ++ ++ outSize = 0; ++ for (i = 0; i < 4; i++) { ++ outSize += (unsigned int)(header[5+i]) << (i * 8); ++ } ++ ++ if (outSize == 0xFFFFFFFF) { ++ fprintf(stderr, "stream version is not supported\n"); ++ return 1; ++ } ++ ++ for (i = 0; i < 4; i++) { ++ if (header[9+i] != 0) { ++ fprintf(stderr, "file too big (bigger than 4 GB)\n"); ++ return 1; ++ } ++ } ++ ++ prop0 = header[0]; ++ if (prop0 >= (9*5*5)) { ++ fprintf(stderr, "Properties error\n"); ++ return 1; ++ } ++ pb = prop0 / 45; ++ prop0 = prop0 % 45; ++ lp = prop0 / 9; ++ lc = prop0 % 9; ++ lzmaInternalSize = ++ (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp)))* sizeof(CProb); ++ /* because we a reusing _LZMA_OUT_READ */ ++ lzmaInternalSize += 100; ++ ++ lzmaInternalData = malloc(lzmaInternalSize); ++ if (lzmaInternalData == 0) { ++ fprintf(stderr, "malloc error!\n"); ++ return 1; ++ } ++ ++ bo.InCallback.Read = LzmaReadCompressed; ++ bo.Buffer = malloc(_LZMA_READ_BUFFER_SIZE); ++ if (bo.Buffer == 0) { ++ fprintf(stderr, "malloc error!\n"); ++ free(lzmaInternalData); ++ return 1; ++ } ++ bo.fil = inputHandle; ++ ++ for (i = 0; i < 4; i++) { ++ dictionarySize += (UInt32)(header[1 + i]) << (i * 8); ++ } ++ ++ if (dictionarySize == 0) { ++ dictionarySize = 1; ++ /* LZMA decoder can not work with dictionarySize = 0 */ ++ } ++ ++ dictionary = (unsigned char *)malloc(dictionarySize); ++ if (dictionary == 0) { ++ fprintf(stderr, "malloc error!\n"); ++ free(lzmaInternalData); ++ free(bo.Buffer); ++ return 1; ++ } ++ res = LzmaDecoderInit((unsigned char *)lzmaInternalData, ++ lzmaInternalSize, ++ lc, lp, pb, ++ dictionary, dictionarySize, ++ &bo.InCallback); ++ if (res == 0) { ++ out_buffer = malloc (_LZMA_WRITE_BUFFER_SIZE); ++ if(out_buffer==0) { ++ fprintf(stderr, "malloc error!\n"); ++ free(lzmaInternalData); ++ free(bo.Buffer); ++ free(dictionary); ++ return 1; ++ } ++ for (nowPos = 0; nowPos < outSize;) { ++ UInt32 blockSize = outSize - nowPos; ++ if (blockSize > _LZMA_WRITE_BUFFER_SIZE) ++ blockSize = _LZMA_WRITE_BUFFER_SIZE; ++ res = LzmaDecode((unsigned char *)lzmaInternalData, ++ out_buffer, blockSize, &outSizeProcessed); ++ if (res != 0) ++ break; ++ if (outSizeProcessed == 0) { ++ outSize = nowPos; ++ break; ++ } ++ nowPos += outSizeProcessed; ++ write(fileno(stdout),out_buffer,outSizeProcessed); ++ } ++ } ++ free(lzmaInternalData); ++ free(bo.Buffer); ++ free(dictionary); ++ free(out_buffer); ++ if (res != 0) { ++ fprintf(stderr, "\nerror = %d\n", res); ++ return 1; ++ } ++ return 0; ++} ++ +--- busybox-20050614.orig/archival/libunarchive/LzmaDecode.c 1970-01-01 01:00:00.000000000 +0100 ++++ busybox-20050614/archival/libunarchive/LzmaDecode.c 2005-06-15 02:13:59.000000000 +0200 +@@ -0,0 +1,586 @@ +/* + LzmaDecode.c -+ LZMA Decoder ++ LZMA Decoder (optimized for Speed version) + -+ LZMA SDK 4.05 Copyright (c) 1999-2004 Igor Pavlov (2004-08-25) ++ LZMA SDK 4.17 Copyright (c) 1999-2005 Igor Pavlov (2005-04-05) + http://www.7-zip.org/ + + LZMA SDK is licensed under two licenses: @@ -43,9 +208,9 @@ + follow rules of that license. + + SPECIAL EXCEPTION: -+ Igor Pavlov, as the author of this code, expressly permits you to -+ statically or dynamically link your code (or bind by name) to the -+ interfaces of this file without subjecting your linked code to the ++ Igor Pavlov, as the author of this Code, expressly permits you to ++ statically or dynamically link your Code (or bind by name) to the ++ interfaces of this file without subjecting your linked Code to the + terms of the CPL or GNU LGPL. Any modifications or additions + to this file, however, are subject to the LGPL or CPL terms. +*/ @@ -63,242 +228,44 @@ +#define kBitModelTotal (1 << kNumBitModelTotalBits) +#define kNumMoveBits 5 + -+typedef struct _CRangeDecoder -+{ -+ Byte *Buffer; -+ Byte *BufferLim; -+ UInt32 Range; -+ UInt32 Code; -+ #ifdef _LZMA_IN_CB -+ ILzmaInCallback *InCallback; -+ int Result; -+ #endif -+ int ExtraBytes; -+} CRangeDecoder; -+ -+Byte RangeDecoderReadByte(CRangeDecoder *rd) -+{ -+ if (rd->Buffer == rd->BufferLim) -+ { -+ #ifdef _LZMA_IN_CB -+ UInt32 size; -+ rd->Result = rd->InCallback->Read(rd->InCallback, &rd->Buffer, &size); -+ rd->BufferLim = rd->Buffer + size; -+ if (size == 0) -+ #endif -+ { -+ rd->ExtraBytes = 1; -+ return 0xFF; -+ } -+ } -+ return (*rd->Buffer++); -+} -+ -+/* #define ReadByte (*rd->Buffer++) */ -+#define ReadByte (RangeDecoderReadByte(rd)) ++#define RC_READ_BYTE (*Buffer++) + -+void RangeDecoderInit(CRangeDecoder *rd, -+ #ifdef _LZMA_IN_CB -+ ILzmaInCallback *inCallback -+ #else -+ Byte *stream, UInt32 bufferSize -+ #endif -+ ) -+{ -+ int i; -+ #ifdef _LZMA_IN_CB -+ rd->InCallback = inCallback; -+ rd->Buffer = rd->BufferLim = 0; -+ #else -+ rd->Buffer = stream; -+ rd->BufferLim = stream + bufferSize; -+ #endif -+ rd->ExtraBytes = 0; -+ rd->Code = 0; -+ rd->Range = (0xFFFFFFFF); -+ for(i = 0; i < 5; i++) -+ rd->Code = (rd->Code << 8) | ReadByte; -+} ++#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \ ++ { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }} + -+#define RC_INIT_VAR UInt32 range = rd->Range; UInt32 code = rd->Code; -+#define RC_FLUSH_VAR rd->Range = range; rd->Code = code; -+#define RC_NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | ReadByte; } ++#ifdef _LZMA_IN_CB + -+UInt32 RangeDecoderDecodeDirectBits(CRangeDecoder *rd, int numTotalBits) -+{ -+ RC_INIT_VAR -+ UInt32 result = 0; -+ int i; -+ for (i = numTotalBits; i > 0; i--) -+ { -+ /* UInt32 t; */ -+ range >>= 1; ++#define RC_TEST { if (Buffer == BufferLim) \ ++ { UInt32 size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \ ++ BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }} + -+ result <<= 1; -+ if (code >= range) -+ { -+ code -= range; -+ result |= 1; -+ } -+ /* -+ t = (code - range) >> 31; -+ t &= 1; -+ code -= range & (t - 1); -+ result = (result + result) | (1 - t); -+ */ -+ RC_NORMALIZE -+ } -+ RC_FLUSH_VAR -+ return result; -+} ++#define RC_INIT Buffer = BufferLim = 0; RC_INIT2 + -+int RangeDecoderBitDecode(CProb *prob, CRangeDecoder *rd) -+{ -+ UInt32 bound = (rd->Range >> kNumBitModelTotalBits) * *prob; -+ if (rd->Code < bound) -+ { -+ rd->Range = bound; -+ *prob += (kBitModelTotal - *prob) >> kNumMoveBits; -+ if (rd->Range < kTopValue) -+ { -+ rd->Code = (rd->Code << 8) | ReadByte; -+ rd->Range <<= 8; -+ } -+ return 0; -+ } -+ else -+ { -+ rd->Range -= bound; -+ rd->Code -= bound; -+ *prob -= (*prob) >> kNumMoveBits; -+ if (rd->Range < kTopValue) -+ { -+ rd->Code = (rd->Code << 8) | ReadByte; -+ rd->Range <<= 8; -+ } -+ return 1; -+ } -+} ++#else + -+#define RC_GET_BIT2(prob, mi, A0, A1) \ -+ UInt32 bound = (range >> kNumBitModelTotalBits) * *prob; \ -+ if (code < bound) \ -+ { A0; range = bound; *prob += (kBitModelTotal - *prob) >> kNumMoveBits; mi <<= 1; } \ -+ else \ -+ { A1; range -= bound; code -= bound; *prob -= (*prob) >> kNumMoveBits; mi = (mi + mi) + 1; } \ -+ RC_NORMALIZE ++#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; } + -+#define RC_GET_BIT(prob, mi) RC_GET_BIT2(prob, mi, ; , ;) ++#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2 ++ ++#endif + -+int RangeDecoderBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd) -+{ -+ int mi = 1; -+ int i; -+ #ifdef _LZMA_LOC_OPT -+ RC_INIT_VAR -+ #endif -+ for(i = numLevels; i > 0; i--) -+ { -+ #ifdef _LZMA_LOC_OPT -+ CProb *prob = probs + mi; -+ RC_GET_BIT(prob, mi) -+ #else -+ mi = (mi + mi) + RangeDecoderBitDecode(probs + mi, rd); -+ #endif -+ } -+ #ifdef _LZMA_LOC_OPT -+ RC_FLUSH_VAR -+ #endif -+ return mi - (1 << numLevels); -+} ++#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; } + -+int RangeDecoderReverseBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd) -+{ -+ int mi = 1; -+ int i; -+ int symbol = 0; -+ #ifdef _LZMA_LOC_OPT -+ RC_INIT_VAR -+ #endif -+ for(i = 0; i < numLevels; i++) -+ { -+ #ifdef _LZMA_LOC_OPT -+ CProb *prob = probs + mi; -+ RC_GET_BIT2(prob, mi, ; , symbol |= (1 << i)) -+ #else -+ int bit = RangeDecoderBitDecode(probs + mi, rd); -+ mi = mi + mi + bit; -+ symbol |= (bit << i); -+ #endif -+ } -+ #ifdef _LZMA_LOC_OPT -+ RC_FLUSH_VAR -+ #endif -+ return symbol; -+} ++#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound) ++#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits; ++#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits; ++ ++#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \ ++ { UpdateBit0(p); mi <<= 1; A0; } else \ ++ { UpdateBit1(p); mi = (mi + mi) + 1; A1; } ++ ++#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;) + -+Byte LzmaLiteralDecode(CProb *probs, CRangeDecoder *rd) -+{ -+ int symbol = 1; -+ #ifdef _LZMA_LOC_OPT -+ RC_INIT_VAR -+ #endif -+ do -+ { -+ #ifdef _LZMA_LOC_OPT -+ CProb *prob = probs + symbol; -+ RC_GET_BIT(prob, symbol) -+ #else -+ symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd); -+ #endif -+ } -+ while (symbol < 0x100); -+ #ifdef _LZMA_LOC_OPT -+ RC_FLUSH_VAR -+ #endif -+ return symbol; -+} ++#define RangeDecoderBitTreeDecode(probs, numLevels, res) \ ++ { int i = numLevels; res = 1; \ ++ do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \ ++ res -= (1 << numLevels); } + -+Byte LzmaLiteralDecodeMatch(CProb *probs, CRangeDecoder *rd, Byte matchByte) -+{ -+ int symbol = 1; -+ #ifdef _LZMA_LOC_OPT -+ RC_INIT_VAR -+ #endif -+ do -+ { -+ int bit; -+ int matchBit = (matchByte >> 7) & 1; -+ matchByte <<= 1; -+ #ifdef _LZMA_LOC_OPT -+ { -+ CProb *prob = probs + ((1 + matchBit) << 8) + symbol; -+ RC_GET_BIT2(prob, symbol, bit = 0, bit = 1) -+ } -+ #else -+ bit = RangeDecoderBitDecode(probs + ((1 + matchBit) << 8) + symbol, rd); -+ symbol = (symbol << 1) | bit; -+ #endif -+ if (matchBit != bit) -+ { -+ while (symbol < 0x100) -+ { -+ #ifdef _LZMA_LOC_OPT -+ CProb *prob = probs + symbol; -+ RC_GET_BIT(prob, symbol) -+ #else -+ symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd); -+ #endif -+ } -+ break; -+ } -+ } -+ while (symbol < 0x100); -+ #ifdef _LZMA_LOC_OPT -+ RC_FLUSH_VAR -+ #endif -+ return symbol; -+} + +#define kNumPosBitsMax 4 +#define kNumPosStatesMax (1 << kNumPosBitsMax) @@ -317,19 +284,9 @@ +#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) +#define kNumLenProbs (LenHigh + kLenNumHighSymbols) + -+int LzmaLenDecode(CProb *p, CRangeDecoder *rd, int posState) -+{ -+ if(RangeDecoderBitDecode(p + LenChoice, rd) == 0) -+ return RangeDecoderBitTreeDecode(p + LenLow + -+ (posState << kLenNumLowBits), kLenNumLowBits, rd); -+ if(RangeDecoderBitDecode(p + LenChoice2, rd) == 0) -+ return kLenNumLowSymbols + RangeDecoderBitTreeDecode(p + LenMid + -+ (posState << kLenNumMidBits), kLenNumMidBits, rd); -+ return kLenNumLowSymbols + kLenNumMidSymbols + -+ RangeDecoderBitTreeDecode(p + LenHigh, kLenNumHighBits, rd); -+} + +#define kNumStates 12 ++#define kNumLitStates 7 + +#define kStartPosModelIndex 4 +#define kEndPosModelIndex 14 @@ -364,7 +321,13 @@ + +typedef struct _LzmaVarState +{ -+ CRangeDecoder RangeDecoder; ++ Byte *Buffer; ++ Byte *BufferLim; ++ UInt32 Range; ++ UInt32 Code; ++ #ifdef _LZMA_IN_CB ++ ILzmaInCallback *InCallback; ++ #endif + Byte *Dictionary; + UInt32 DictionarySize; + UInt32 DictionaryPos; @@ -374,8 +337,8 @@ + int lp; + int pb; + int State; -+ int PreviousIsMatch; + int RemainLen; ++ Byte TempDictionary[4]; +} LzmaVarState; + +int LzmaDecoderInit( @@ -383,12 +346,16 @@ + int lc, int lp, int pb, + unsigned char *dictionary, UInt32 dictionarySize, + #ifdef _LZMA_IN_CB -+ ILzmaInCallback *inCallback ++ ILzmaInCallback *InCallback + #else + unsigned char *inStream, UInt32 inSize + #endif + ) +{ ++ Byte *Buffer; ++ Byte *BufferLim; ++ UInt32 Range; ++ UInt32 Code; + LzmaVarState *vs = (LzmaVarState *)buffer; + CProb *p = (CProb *)(buffer + sizeof(LzmaVarState)); + UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp)); @@ -404,18 +371,24 @@ + vs->lp = lp; + vs->pb = pb; + vs->State = 0; -+ vs->PreviousIsMatch = 0; + vs->RemainLen = 0; + dictionary[dictionarySize - 1] = 0; + for (i = 0; i < numProbs; i++) <<Diff was trimmed, longer than 597 lines>> ---- CVS-web: http://cvs.pld-linux.org/SOURCES/busybox-lzmacat.diff?r1=1.1&r2=1.2&f=u _______________________________________________ pld-cvs-commit mailing list pld-cvs-commit@lists.pld-linux.org http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit