Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
OS
U-Boot.Mirror
提交
ae644800
U
U-Boot.Mirror
项目概览
OS
/
U-Boot.Mirror
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
U
U-Boot.Mirror
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
ae644800
编写于
3月 08, 2002
作者:
W
wdenk
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Initial revision
上级
012771d8
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
396 addition
and
0 deletion
+396
-0
fs/jffs2/mini_inflate.c
fs/jffs2/mini_inflate.c
+396
-0
未找到文件。
fs/jffs2/mini_inflate.c
0 → 100644
浏览文件 @
ae644800
/*-------------------------------------------------------------------------
* Filename: mini_inflate.c
* Version: $Id: mini_inflate.c,v 1.3 2002/01/24 22:58:42 rfeany Exp $
* Copyright: Copyright (C) 2001, Russ Dill
* Author: Russ Dill <Russ.Dill@asu.edu>
* Description: Mini inflate implementation (RFC 1951)
*-----------------------------------------------------------------------*/
/*
*
* 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
*
*/
#include <config.h>
#if (CONFIG_COMMANDS & CFG_CMD_JFFS2)
#include <jffs2/mini_inflate.h>
/* The order that the code lengths in section 3.2.7 are in */
static
unsigned
char
huffman_order
[]
=
{
16
,
17
,
18
,
0
,
8
,
7
,
9
,
6
,
10
,
5
,
11
,
4
,
12
,
3
,
13
,
2
,
14
,
1
,
15
};
inline
void
cramfs_memset
(
int
*
s
,
const
int
c
,
size
n
)
{
n
--
;
for
(;
n
>
0
;
n
--
)
s
[
n
]
=
c
;
s
[
0
]
=
c
;
}
/* associate a stream with a block of data and reset the stream */
static
void
init_stream
(
struct
bitstream
*
stream
,
unsigned
char
*
data
,
void
*
(
*
inflate_memcpy
)(
void
*
,
const
void
*
,
size
))
{
stream
->
error
=
NO_ERROR
;
stream
->
memcpy
=
inflate_memcpy
;
stream
->
decoded
=
0
;
stream
->
data
=
data
;
stream
->
bit
=
0
;
/* The first bit of the stream is the lsb of the
* first byte */
/* really sorry about all this initialization, think of a better way,
* let me know and it will get cleaned up */
stream
->
codes
.
bits
=
8
;
stream
->
codes
.
num_symbols
=
19
;
stream
->
codes
.
lengths
=
stream
->
code_lengths
;
stream
->
codes
.
symbols
=
stream
->
code_symbols
;
stream
->
codes
.
count
=
stream
->
code_count
;
stream
->
codes
.
first
=
stream
->
code_first
;
stream
->
codes
.
pos
=
stream
->
code_pos
;
stream
->
lengths
.
bits
=
16
;
stream
->
lengths
.
num_symbols
=
288
;
stream
->
lengths
.
lengths
=
stream
->
length_lengths
;
stream
->
lengths
.
symbols
=
stream
->
length_symbols
;
stream
->
lengths
.
count
=
stream
->
length_count
;
stream
->
lengths
.
first
=
stream
->
length_first
;
stream
->
lengths
.
pos
=
stream
->
length_pos
;
stream
->
distance
.
bits
=
16
;
stream
->
distance
.
num_symbols
=
32
;
stream
->
distance
.
lengths
=
stream
->
distance_lengths
;
stream
->
distance
.
symbols
=
stream
->
distance_symbols
;
stream
->
distance
.
count
=
stream
->
distance_count
;
stream
->
distance
.
first
=
stream
->
distance_first
;
stream
->
distance
.
pos
=
stream
->
distance_pos
;
}
/* pull 'bits' bits out of the stream. The last bit pulled it returned as the
* msb. (section 3.1.1)
*/
inline
unsigned
long
pull_bits
(
struct
bitstream
*
stream
,
const
unsigned
int
bits
)
{
unsigned
long
ret
;
int
i
;
ret
=
0
;
for
(
i
=
0
;
i
<
bits
;
i
++
)
{
ret
+=
((
*
(
stream
->
data
)
>>
stream
->
bit
)
&
1
)
<<
i
;
/* if, before incrementing, we are on bit 7,
* go to the lsb of the next byte */
if
(
stream
->
bit
++
==
7
)
{
stream
->
bit
=
0
;
stream
->
data
++
;
}
}
return
ret
;
}
inline
int
pull_bit
(
struct
bitstream
*
stream
)
{
int
ret
=
((
*
(
stream
->
data
)
>>
stream
->
bit
)
&
1
);
if
(
stream
->
bit
++
==
7
)
{
stream
->
bit
=
0
;
stream
->
data
++
;
}
return
ret
;
}
/* discard bits up to the next whole byte */
static
void
discard_bits
(
struct
bitstream
*
stream
)
{
if
(
stream
->
bit
!=
0
)
{
stream
->
bit
=
0
;
stream
->
data
++
;
}
}
/* No decompression, the data is all literals (section 3.2.4) */
static
void
decompress_none
(
struct
bitstream
*
stream
,
unsigned
char
*
dest
)
{
unsigned
int
length
;
discard_bits
(
stream
);
length
=
*
(
stream
->
data
++
);
length
+=
*
(
stream
->
data
++
)
<<
8
;
pull_bits
(
stream
,
16
);
/* throw away the inverse of the size */
stream
->
decoded
+=
length
;
stream
->
memcpy
(
dest
,
stream
->
data
,
length
);
stream
->
data
+=
length
;
}
/* Read in a symbol from the stream (section 3.2.2) */
static
int
read_symbol
(
struct
bitstream
*
stream
,
struct
huffman_set
*
set
)
{
int
bits
=
0
;
int
code
=
0
;
while
(
!
(
set
->
count
[
bits
]
&&
code
<
set
->
first
[
bits
]
+
set
->
count
[
bits
]))
{
code
=
(
code
<<
1
)
+
pull_bit
(
stream
);
if
(
++
bits
>
set
->
bits
)
{
/* error decoding (corrupted data?) */
stream
->
error
=
CODE_NOT_FOUND
;
return
-
1
;
}
}
return
set
->
symbols
[
set
->
pos
[
bits
]
+
code
-
set
->
first
[
bits
]];
}
/* decompress a stream of data encoded with the passed length and distance
* huffman codes */
static
void
decompress_huffman
(
struct
bitstream
*
stream
,
unsigned
char
*
dest
)
{
struct
huffman_set
*
lengths
=
&
(
stream
->
lengths
);
struct
huffman_set
*
distance
=
&
(
stream
->
distance
);
int
symbol
,
length
,
dist
,
i
;
do
{
if
((
symbol
=
read_symbol
(
stream
,
lengths
))
<
0
)
return
;
if
(
symbol
<
256
)
{
*
(
dest
++
)
=
symbol
;
/* symbol is a literal */
stream
->
decoded
++
;
}
else
if
(
symbol
>
256
)
{
/* Determine the length of the repitition
* (section 3.2.5) */
if
(
symbol
<
265
)
length
=
symbol
-
254
;
else
if
(
symbol
==
285
)
length
=
258
;
else
{
length
=
pull_bits
(
stream
,
(
symbol
-
261
)
>>
2
);
length
+=
(
4
<<
((
symbol
-
261
)
>>
2
))
+
3
;
length
+=
((
symbol
-
1
)
%
4
)
<<
((
symbol
-
261
)
>>
2
);
}
/* Determine how far back to go */
if
((
symbol
=
read_symbol
(
stream
,
distance
))
<
0
)
return
;
if
(
symbol
<
4
)
dist
=
symbol
+
1
;
else
{
dist
=
pull_bits
(
stream
,
(
symbol
-
2
)
>>
1
);
dist
+=
(
2
<<
((
symbol
-
2
)
>>
1
))
+
1
;
dist
+=
(
symbol
%
2
)
<<
((
symbol
-
2
)
>>
1
);
}
stream
->
decoded
+=
length
;
for
(
i
=
0
;
i
<
length
;
i
++
)
{
*
dest
=
dest
[
-
dist
];
dest
++
;
}
}
}
while
(
symbol
!=
256
);
/* 256 is the end of the data block */
}
/* Fill the lookup tables (section 3.2.2) */
static
void
fill_code_tables
(
struct
huffman_set
*
set
)
{
int
code
=
0
,
i
,
length
;
/* fill in the first code of each bit length, and the pos pointer */
set
->
pos
[
0
]
=
0
;
for
(
i
=
1
;
i
<
set
->
bits
;
i
++
)
{
code
=
(
code
+
set
->
count
[
i
-
1
])
<<
1
;
set
->
first
[
i
]
=
code
;
set
->
pos
[
i
]
=
set
->
pos
[
i
-
1
]
+
set
->
count
[
i
-
1
];
}
/* Fill in the table of symbols in order of their huffman code */
for
(
i
=
0
;
i
<
set
->
num_symbols
;
i
++
)
{
if
((
length
=
set
->
lengths
[
i
]))
set
->
symbols
[
set
->
pos
[
length
]
++
]
=
i
;
}
/* reset the pos pointer */
for
(
i
=
1
;
i
<
set
->
bits
;
i
++
)
set
->
pos
[
i
]
-=
set
->
count
[
i
];
}
static
void
init_code_tables
(
struct
huffman_set
*
set
)
{
cramfs_memset
(
set
->
lengths
,
0
,
set
->
num_symbols
);
cramfs_memset
(
set
->
count
,
0
,
set
->
bits
);
cramfs_memset
(
set
->
first
,
0
,
set
->
bits
);
}
/* read in the huffman codes for dynamic decoding (section 3.2.7) */
static
void
decompress_dynamic
(
struct
bitstream
*
stream
,
unsigned
char
*
dest
)
{
/* I tried my best to minimize the memory footprint here, while still
* keeping up performance. I really dislike the _lengths[] tables, but
* I see no way of eliminating them without a sizable performance
* impact. The first struct table keeps track of stats on each bit
* length. The _length table keeps a record of the bit length of each
* symbol. The _symbols table is for looking up symbols by the huffman
* code (the pos element points to the first place in the symbol table
* where that bit length occurs). I also hate the initization of these
* structs, if someone knows how to compact these, lemme know. */
struct
huffman_set
*
codes
=
&
(
stream
->
codes
);
struct
huffman_set
*
lengths
=
&
(
stream
->
lengths
);
struct
huffman_set
*
distance
=
&
(
stream
->
distance
);
int
hlit
=
pull_bits
(
stream
,
5
)
+
257
;
int
hdist
=
pull_bits
(
stream
,
5
)
+
1
;
int
hclen
=
pull_bits
(
stream
,
4
)
+
4
;
int
length
,
curr_code
,
symbol
,
i
,
last_code
;
last_code
=
0
;
init_code_tables
(
codes
);
init_code_tables
(
lengths
);
init_code_tables
(
distance
);
/* fill in the count of each bit length' as well as the lengths
* table */
for
(
i
=
0
;
i
<
hclen
;
i
++
)
{
length
=
pull_bits
(
stream
,
3
);
codes
->
lengths
[
huffman_order
[
i
]]
=
length
;
if
(
length
)
codes
->
count
[
length
]
++
;
}
fill_code_tables
(
codes
);
/* Do the same for the length codes, being carefull of wrap through
* to the distance table */
curr_code
=
0
;
while
(
curr_code
<
hlit
)
{
if
((
symbol
=
read_symbol
(
stream
,
codes
))
<
0
)
return
;
if
(
symbol
==
0
)
{
curr_code
++
;
last_code
=
0
;
}
else
if
(
symbol
<
16
)
{
/* Literal length */
lengths
->
lengths
[
curr_code
]
=
last_code
=
symbol
;
lengths
->
count
[
symbol
]
++
;
curr_code
++
;
}
else
if
(
symbol
==
16
)
{
/* repeat the last symbol 3 - 6
* times */
length
=
3
+
pull_bits
(
stream
,
2
);
for
(;
length
;
length
--
,
curr_code
++
)
if
(
curr_code
<
hlit
)
{
lengths
->
lengths
[
curr_code
]
=
last_code
;
lengths
->
count
[
last_code
]
++
;
}
else
{
/* wrap to the distance table */
distance
->
lengths
[
curr_code
-
hlit
]
=
last_code
;
distance
->
count
[
last_code
]
++
;
}
}
else
if
(
symbol
==
17
)
{
/* repeat a bit length 0 */
curr_code
+=
3
+
pull_bits
(
stream
,
3
);
last_code
=
0
;
}
else
{
/* same, but more times */
curr_code
+=
11
+
pull_bits
(
stream
,
7
);
last_code
=
0
;
}
}
fill_code_tables
(
lengths
);
/* Fill the distance table, don't need to worry about wrapthrough
* here */
curr_code
-=
hlit
;
while
(
curr_code
<
hdist
)
{
if
((
symbol
=
read_symbol
(
stream
,
codes
))
<
0
)
return
;
if
(
symbol
==
0
)
{
curr_code
++
;
last_code
=
0
;
}
else
if
(
symbol
<
16
)
{
distance
->
lengths
[
curr_code
]
=
last_code
=
symbol
;
distance
->
count
[
symbol
]
++
;
curr_code
++
;
}
else
if
(
symbol
==
16
)
{
length
=
3
+
pull_bits
(
stream
,
2
);
for
(;
length
;
length
--
,
curr_code
++
)
{
distance
->
lengths
[
curr_code
]
=
last_code
;
distance
->
count
[
last_code
]
++
;
}
}
else
if
(
symbol
==
17
)
{
curr_code
+=
3
+
pull_bits
(
stream
,
3
);
last_code
=
0
;
}
else
{
curr_code
+=
11
+
pull_bits
(
stream
,
7
);
last_code
=
0
;
}
}
fill_code_tables
(
distance
);
decompress_huffman
(
stream
,
dest
);
}
/* fill in the length and distance huffman codes for fixed encoding
* (section 3.2.6) */
static
void
decompress_fixed
(
struct
bitstream
*
stream
,
unsigned
char
*
dest
)
{
/* let gcc fill in the initial values */
struct
huffman_set
*
lengths
=
&
(
stream
->
lengths
);
struct
huffman_set
*
distance
=
&
(
stream
->
distance
);
cramfs_memset
(
lengths
->
count
,
0
,
16
);
cramfs_memset
(
lengths
->
first
,
0
,
16
);
cramfs_memset
(
lengths
->
lengths
,
8
,
144
);
cramfs_memset
(
lengths
->
lengths
+
144
,
9
,
112
);
cramfs_memset
(
lengths
->
lengths
+
256
,
7
,
24
);
cramfs_memset
(
lengths
->
lengths
+
280
,
8
,
8
);
lengths
->
count
[
7
]
=
24
;
lengths
->
count
[
8
]
=
152
;
lengths
->
count
[
9
]
=
112
;
cramfs_memset
(
distance
->
count
,
0
,
16
);
cramfs_memset
(
distance
->
first
,
0
,
16
);
cramfs_memset
(
distance
->
lengths
,
5
,
32
);
distance
->
count
[
5
]
=
32
;
fill_code_tables
(
lengths
);
fill_code_tables
(
distance
);
decompress_huffman
(
stream
,
dest
);
}
/* returns the number of bytes decoded, < 0 if there was an error. Note that
* this function assumes that the block starts on a byte boundry
* (non-compliant, but I don't see where this would happen). section 3.2.3 */
long
decompress_block
(
unsigned
char
*
dest
,
unsigned
char
*
source
,
void
*
(
*
inflate_memcpy
)(
void
*
,
const
void
*
,
size
))
{
int
bfinal
,
btype
;
struct
bitstream
stream
;
init_stream
(
&
stream
,
source
,
inflate_memcpy
);
do
{
bfinal
=
pull_bit
(
&
stream
);
btype
=
pull_bits
(
&
stream
,
2
);
if
(
btype
==
NO_COMP
)
decompress_none
(
&
stream
,
dest
+
stream
.
decoded
);
else
if
(
btype
==
DYNAMIC_COMP
)
decompress_dynamic
(
&
stream
,
dest
+
stream
.
decoded
);
else
if
(
btype
==
FIXED_COMP
)
decompress_fixed
(
&
stream
,
dest
+
stream
.
decoded
);
else
stream
.
error
=
COMP_UNKNOWN
;
}
while
(
!
bfinal
&&
!
stream
.
error
);
#if 0
putstr("decompress_block start\r\n");
putLabeledWord("stream.error = ",stream.error);
putLabeledWord("stream.decoded = ",stream.decoded);
putLabeledWord("dest = ",dest);
putstr("decompress_block end\r\n");
#endif
return
stream
.
error
?
-
stream
.
error
:
stream
.
decoded
;
}
#endif
/* CFG_CMD_JFFS2 */
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录