Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
itdan3344
stb
提交
d5272d32
S
stb
项目概览
itdan3344
/
stb
与 Fork 源项目一致
从无法访问的项目Fork
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
S
stb
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
d5272d32
编写于
5月 31, 2014
作者:
S
Sean Barrett
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
renaming completed through png decoder
上级
7add5044
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
153 addition
and
152 deletion
+153
-152
stb_image.h
stb_image.h
+153
-152
未找到文件。
stb_image.h
浏览文件 @
d5272d32
...
...
@@ -1977,22 +1977,22 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
// - fast huffman
// fast-way is faster to check than jpeg huffman, but slow way is slower
#define ZFAST_BITS 9 // accelerate all cases in default tables
#define
ZFAST_MASK ((1 <<
ZFAST_BITS) - 1)
#define
STBI__
ZFAST_BITS 9 // accelerate all cases in default tables
#define
STBI__ZFAST_MASK ((1 << STBI__
ZFAST_BITS) - 1)
// zlib-style huffman encoding
// (jpegs packs from left, zlib from right, so can't share code)
typedef
struct
{
stbi__uint16
fast
[
1
<<
ZFAST_BITS
];
stbi__uint16
fast
[
1
<<
STBI__
ZFAST_BITS
];
stbi__uint16
firstcode
[
16
];
int
maxcode
[
17
];
stbi__uint16
firstsymbol
[
16
];
stbi__uint8
size
[
288
];
stbi__uint16
value
[
288
];
}
zhuffman
;
}
stbi__
zhuffman
;
stbi_inline
static
int
bitreverse16
(
int
n
)
stbi_inline
static
int
stbi__
bitreverse16
(
int
n
)
{
n
=
((
n
&
0xAAAA
)
>>
1
)
|
((
n
&
0x5555
)
<<
1
);
n
=
((
n
&
0xCCCC
)
>>
2
)
|
((
n
&
0x3333
)
<<
2
);
...
...
@@ -2001,15 +2001,15 @@ stbi_inline static int bitreverse16(int n)
return
n
;
}
stbi_inline
static
int
bit_reverse
(
int
v
,
int
bits
)
stbi_inline
static
int
stbi__
bit_reverse
(
int
v
,
int
bits
)
{
assert
(
bits
<=
16
);
// to bit reverse n bits, reverse 16 and shift
// stbi__err.g. 11 bits, bit reverse and shift away 5
return
bitreverse16
(
v
)
>>
(
16
-
bits
);
return
stbi__
bitreverse16
(
v
)
>>
(
16
-
bits
);
}
static
int
zbuild_huffman
(
zhuffman
*
z
,
stbi__uint8
*
sizelist
,
int
num
)
static
int
stbi__zbuild_huffman
(
stbi__
zhuffman
*
z
,
stbi__uint8
*
sizelist
,
int
num
)
{
int
i
,
k
=
0
;
int
code
,
next_code
[
16
],
sizes
[
17
];
...
...
@@ -2041,9 +2041,9 @@ static int zbuild_huffman(zhuffman *z, stbi__uint8 *sizelist, int num)
int
c
=
next_code
[
s
]
-
z
->
firstcode
[
s
]
+
z
->
firstsymbol
[
s
];
z
->
size
[
c
]
=
(
stbi__uint8
)
s
;
z
->
value
[
c
]
=
(
stbi__uint16
)
i
;
if
(
s
<=
ZFAST_BITS
)
{
int
k
=
bit_reverse
(
next_code
[
s
],
s
);
while
(
k
<
(
1
<<
ZFAST_BITS
))
{
if
(
s
<=
STBI__
ZFAST_BITS
)
{
int
k
=
stbi__
bit_reverse
(
next_code
[
s
],
s
);
while
(
k
<
(
1
<<
STBI__
ZFAST_BITS
))
{
z
->
fast
[
k
]
=
(
stbi__uint16
)
c
;
k
+=
(
1
<<
s
);
}
...
...
@@ -2071,39 +2071,39 @@ typedef struct
char
*
zout_end
;
int
z_expandable
;
zhuffman
z_length
,
z_distance
;
}
zbuf
;
stbi__
zhuffman
z_length
,
z_distance
;
}
stbi__
zbuf
;
stbi_inline
static
int
zget8
(
zbuf
*
z
)
stbi_inline
static
int
stbi__zget8
(
stbi__
zbuf
*
z
)
{
if
(
z
->
zbuffer
>=
z
->
zbuffer_end
)
return
0
;
return
*
z
->
zbuffer
++
;
}
static
void
fill_bits
(
zbuf
*
z
)
static
void
stbi__fill_bits
(
stbi__
zbuf
*
z
)
{
do
{
assert
(
z
->
code_buffer
<
(
1U
<<
z
->
num_bits
));
z
->
code_buffer
|=
zget8
(
z
)
<<
z
->
num_bits
;
z
->
code_buffer
|=
stbi__
zget8
(
z
)
<<
z
->
num_bits
;
z
->
num_bits
+=
8
;
}
while
(
z
->
num_bits
<=
24
);
}
stbi_inline
static
unsigned
int
zreceive
(
zbuf
*
z
,
int
n
)
stbi_inline
static
unsigned
int
stbi__zreceive
(
stbi__
zbuf
*
z
,
int
n
)
{
unsigned
int
k
;
if
(
z
->
num_bits
<
n
)
fill_bits
(
z
);
if
(
z
->
num_bits
<
n
)
stbi__
fill_bits
(
z
);
k
=
z
->
code_buffer
&
((
1
<<
n
)
-
1
);
z
->
code_buffer
>>=
n
;
z
->
num_bits
-=
n
;
return
k
;
}
stbi_inline
static
int
zhuffman_decode
(
zbuf
*
a
,
zhuffman
*
z
)
stbi_inline
static
int
stbi__zhuffman_decode
(
stbi__zbuf
*
a
,
stbi__
zhuffman
*
z
)
{
int
b
,
s
,
k
;
if
(
a
->
num_bits
<
16
)
fill_bits
(
a
);
b
=
z
->
fast
[
a
->
code_buffer
&
ZFAST_MASK
];
if
(
a
->
num_bits
<
16
)
stbi__
fill_bits
(
a
);
b
=
z
->
fast
[
a
->
code_buffer
&
STBI__
ZFAST_MASK
];
if
(
b
<
0xffff
)
{
s
=
z
->
size
[
b
];
a
->
code_buffer
>>=
s
;
...
...
@@ -2113,8 +2113,8 @@ stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z)
// not resolved by fast table, so compute it the slow way
// use jpeg approach, which requires MSbits at top
k
=
bit_reverse
(
a
->
code_buffer
,
16
);
for
(
s
=
ZFAST_BITS
+
1
;
;
++
s
)
k
=
stbi__
bit_reverse
(
a
->
code_buffer
,
16
);
for
(
s
=
STBI__
ZFAST_BITS
+
1
;
;
++
s
)
if
(
k
<
z
->
maxcode
[
s
])
break
;
if
(
s
==
16
)
return
-
1
;
// invalid code!
...
...
@@ -2126,7 +2126,7 @@ stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z)
return
z
->
value
[
b
];
}
static
int
expand
(
zbuf
*
z
,
int
n
)
// need to make room for n bytes
static
int
stbi__zexpand
(
stbi__
zbuf
*
z
,
int
n
)
// need to make room for n bytes
{
char
*
q
;
int
cur
,
limit
;
...
...
@@ -2143,41 +2143,41 @@ static int expand(zbuf *z, int n) // need to make room for n bytes
return
1
;
}
static
int
length_base
[
31
]
=
{
static
int
stbi__z
length_base
[
31
]
=
{
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
,
11
,
13
,
15
,
17
,
19
,
23
,
27
,
31
,
35
,
43
,
51
,
59
,
67
,
83
,
99
,
115
,
131
,
163
,
195
,
227
,
258
,
0
,
0
};
static
int
length_extra
[
31
]
=
static
int
stbi__z
length_extra
[
31
]
=
{
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
1
,
1
,
1
,
1
,
2
,
2
,
2
,
2
,
3
,
3
,
3
,
3
,
4
,
4
,
4
,
4
,
5
,
5
,
5
,
5
,
0
,
0
,
0
};
static
int
dist_base
[
32
]
=
{
1
,
2
,
3
,
4
,
5
,
7
,
9
,
13
,
17
,
25
,
33
,
49
,
65
,
97
,
129
,
193
,
static
int
stbi__z
dist_base
[
32
]
=
{
1
,
2
,
3
,
4
,
5
,
7
,
9
,
13
,
17
,
25
,
33
,
49
,
65
,
97
,
129
,
193
,
257
,
385
,
513
,
769
,
1025
,
1537
,
2049
,
3073
,
4097
,
6145
,
8193
,
12289
,
16385
,
24577
,
0
,
0
};
static
int
dist_extra
[
32
]
=
static
int
stbi__z
dist_extra
[
32
]
=
{
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
};
static
int
parse_huffman_block
(
zbuf
*
a
)
static
int
stbi__parse_huffman_block
(
stbi__
zbuf
*
a
)
{
for
(;;)
{
int
z
=
zhuffman_decode
(
a
,
&
a
->
z_length
);
int
z
=
stbi__
zhuffman_decode
(
a
,
&
a
->
z_length
);
if
(
z
<
256
)
{
if
(
z
<
0
)
return
stbi__err
(
"bad huffman code"
,
"Corrupt PNG"
);
// error in huffman codes
if
(
a
->
zout
>=
a
->
zout_end
)
if
(
!
expand
(
a
,
1
))
return
0
;
if
(
a
->
zout
>=
a
->
zout_end
)
if
(
!
stbi__z
expand
(
a
,
1
))
return
0
;
*
a
->
zout
++
=
(
char
)
z
;
}
else
{
stbi__uint8
*
p
;
int
len
,
dist
;
if
(
z
==
256
)
return
1
;
z
-=
257
;
len
=
length_base
[
z
];
if
(
length_extra
[
z
])
len
+=
zreceive
(
a
,
length_extra
[
z
]);
z
=
zhuffman_decode
(
a
,
&
a
->
z_distance
);
len
=
stbi__z
length_base
[
z
];
if
(
stbi__zlength_extra
[
z
])
len
+=
stbi__zreceive
(
a
,
stbi__z
length_extra
[
z
]);
z
=
stbi__
zhuffman_decode
(
a
,
&
a
->
z_distance
);
if
(
z
<
0
)
return
stbi__err
(
"bad huffman code"
,
"Corrupt PNG"
);
dist
=
dist_base
[
z
];
if
(
dist_extra
[
z
])
dist
+=
zreceive
(
a
,
dist_extra
[
z
]);
dist
=
stbi__z
dist_base
[
z
];
if
(
stbi__zdist_extra
[
z
])
dist
+=
stbi__zreceive
(
a
,
stbi__z
dist_extra
[
z
]);
if
(
a
->
zout
-
a
->
zout_start
<
dist
)
return
stbi__err
(
"bad dist"
,
"Corrupt PNG"
);
if
(
a
->
zout
+
len
>
a
->
zout_end
)
if
(
!
expand
(
a
,
len
))
return
0
;
if
(
a
->
zout
+
len
>
a
->
zout_end
)
if
(
!
stbi__z
expand
(
a
,
len
))
return
0
;
p
=
(
stbi__uint8
*
)
(
a
->
zout
-
dist
);
while
(
len
--
)
*
a
->
zout
++
=
*
p
++
;
...
...
@@ -2185,58 +2185,58 @@ static int parse_huffman_block(zbuf *a)
}
}
static
int
compute_huffman_codes
(
zbuf
*
a
)
static
int
stbi__compute_huffman_codes
(
stbi__
zbuf
*
a
)
{
static
stbi__uint8
length_dezigzag
[
19
]
=
{
16
,
17
,
18
,
0
,
8
,
7
,
9
,
6
,
10
,
5
,
11
,
4
,
12
,
3
,
13
,
2
,
14
,
1
,
15
};
zhuffman
z_codelength
;
stbi__
zhuffman
z_codelength
;
stbi__uint8
lencodes
[
286
+
32
+
137
];
//padding for maximum single op
stbi__uint8
codelength_sizes
[
19
];
int
i
,
n
;
int
hlit
=
zreceive
(
a
,
5
)
+
257
;
int
hdist
=
zreceive
(
a
,
5
)
+
1
;
int
hclen
=
zreceive
(
a
,
4
)
+
4
;
int
hlit
=
stbi__
zreceive
(
a
,
5
)
+
257
;
int
hdist
=
stbi__
zreceive
(
a
,
5
)
+
1
;
int
hclen
=
stbi__
zreceive
(
a
,
4
)
+
4
;
memset
(
codelength_sizes
,
0
,
sizeof
(
codelength_sizes
));
for
(
i
=
0
;
i
<
hclen
;
++
i
)
{
int
s
=
zreceive
(
a
,
3
);
int
s
=
stbi__
zreceive
(
a
,
3
);
codelength_sizes
[
length_dezigzag
[
i
]]
=
(
stbi__uint8
)
s
;
}
if
(
!
zbuild_huffman
(
&
z_codelength
,
codelength_sizes
,
19
))
return
0
;
if
(
!
stbi__
zbuild_huffman
(
&
z_codelength
,
codelength_sizes
,
19
))
return
0
;
n
=
0
;
while
(
n
<
hlit
+
hdist
)
{
int
c
=
zhuffman_decode
(
a
,
&
z_codelength
);
int
c
=
stbi__
zhuffman_decode
(
a
,
&
z_codelength
);
assert
(
c
>=
0
&&
c
<
19
);
if
(
c
<
16
)
lencodes
[
n
++
]
=
(
stbi__uint8
)
c
;
else
if
(
c
==
16
)
{
c
=
zreceive
(
a
,
2
)
+
3
;
c
=
stbi__
zreceive
(
a
,
2
)
+
3
;
memset
(
lencodes
+
n
,
lencodes
[
n
-
1
],
c
);
n
+=
c
;
}
else
if
(
c
==
17
)
{
c
=
zreceive
(
a
,
3
)
+
3
;
c
=
stbi__
zreceive
(
a
,
3
)
+
3
;
memset
(
lencodes
+
n
,
0
,
c
);
n
+=
c
;
}
else
{
assert
(
c
==
18
);
c
=
zreceive
(
a
,
7
)
+
11
;
c
=
stbi__
zreceive
(
a
,
7
)
+
11
;
memset
(
lencodes
+
n
,
0
,
c
);
n
+=
c
;
}
}
if
(
n
!=
hlit
+
hdist
)
return
stbi__err
(
"bad codelengths"
,
"Corrupt PNG"
);
if
(
!
zbuild_huffman
(
&
a
->
z_length
,
lencodes
,
hlit
))
return
0
;
if
(
!
zbuild_huffman
(
&
a
->
z_distance
,
lencodes
+
hlit
,
hdist
))
return
0
;
if
(
!
stbi__
zbuild_huffman
(
&
a
->
z_length
,
lencodes
,
hlit
))
return
0
;
if
(
!
stbi__
zbuild_huffman
(
&
a
->
z_distance
,
lencodes
+
hlit
,
hdist
))
return
0
;
return
1
;
}
static
int
parse_uncompressed_block
(
zbuf
*
a
)
static
int
stbi__parse_uncomperssed_block
(
stbi__
zbuf
*
a
)
{
stbi__uint8
header
[
4
];
int
len
,
nlen
,
k
;
if
(
a
->
num_bits
&
7
)
zreceive
(
a
,
a
->
num_bits
&
7
);
// discard
stbi__
zreceive
(
a
,
a
->
num_bits
&
7
);
// discard
// drain the bit-packed data into header
k
=
0
;
while
(
a
->
num_bits
>
0
)
{
...
...
@@ -2247,25 +2247,25 @@ static int parse_uncompressed_block(zbuf *a)
assert
(
a
->
num_bits
==
0
);
// now fill header the normal way
while
(
k
<
4
)
header
[
k
++
]
=
(
stbi__uint8
)
zget8
(
a
);
header
[
k
++
]
=
(
stbi__uint8
)
stbi__
zget8
(
a
);
len
=
header
[
1
]
*
256
+
header
[
0
];
nlen
=
header
[
3
]
*
256
+
header
[
2
];
if
(
nlen
!=
(
len
^
0xffff
))
return
stbi__err
(
"zlib corrupt"
,
"Corrupt PNG"
);
if
(
a
->
zbuffer
+
len
>
a
->
zbuffer_end
)
return
stbi__err
(
"read past buffer"
,
"Corrupt PNG"
);
if
(
a
->
zout
+
len
>
a
->
zout_end
)
if
(
!
expand
(
a
,
len
))
return
0
;
if
(
!
stbi__z
expand
(
a
,
len
))
return
0
;
memcpy
(
a
->
zout
,
a
->
zbuffer
,
len
);
a
->
zbuffer
+=
len
;
a
->
zout
+=
len
;
return
1
;
}
static
int
parse_zlib_header
(
zbuf
*
a
)
static
int
stbi__parse_zlib_header
(
stbi__
zbuf
*
a
)
{
int
cmf
=
zget8
(
a
);
int
cmf
=
stbi__
zget8
(
a
);
int
cm
=
cmf
&
15
;
/* int cinfo = cmf >> 4; */
int
flg
=
zget8
(
a
);
int
flg
=
stbi__
zget8
(
a
);
if
((
cmf
*
256
+
flg
)
%
31
!=
0
)
return
stbi__err
(
"bad zlib header"
,
"Corrupt PNG"
);
// zlib spec
if
(
flg
&
32
)
return
stbi__err
(
"no preset dict"
,
"Corrupt PNG"
);
// preset dictionary not allowed in png
if
(
cm
!=
8
)
return
stbi__err
(
"bad compression"
,
"Corrupt PNG"
);
// DEFLATE required for png
...
...
@@ -2274,65 +2274,65 @@ static int parse_zlib_header(zbuf *a)
}
// @TODO: should statically initialize these for optimal thread safety
static
stbi__uint8
default_length
[
288
],
default_distance
[
32
];
static
void
init_
defaults
(
void
)
static
stbi__uint8
stbi__zdefault_length
[
288
],
stbi__z
default_distance
[
32
];
static
void
stbi__init_z
defaults
(
void
)
{
int
i
;
// use <= to match clearly with spec
for
(
i
=
0
;
i
<=
143
;
++
i
)
default_length
[
i
]
=
8
;
for
(
;
i
<=
255
;
++
i
)
default_length
[
i
]
=
9
;
for
(
;
i
<=
279
;
++
i
)
default_length
[
i
]
=
7
;
for
(
;
i
<=
287
;
++
i
)
default_length
[
i
]
=
8
;
for
(
i
=
0
;
i
<=
143
;
++
i
)
stbi__z
default_length
[
i
]
=
8
;
for
(
;
i
<=
255
;
++
i
)
stbi__z
default_length
[
i
]
=
9
;
for
(
;
i
<=
279
;
++
i
)
stbi__z
default_length
[
i
]
=
7
;
for
(
;
i
<=
287
;
++
i
)
stbi__z
default_length
[
i
]
=
8
;
for
(
i
=
0
;
i
<=
31
;
++
i
)
default_distance
[
i
]
=
5
;
for
(
i
=
0
;
i
<=
31
;
++
i
)
stbi__z
default_distance
[
i
]
=
5
;
}
static
int
parse_zlib
(
zbuf
*
a
,
int
parse_header
)
static
int
stbi__parse_zlib
(
stbi__
zbuf
*
a
,
int
parse_header
)
{
int
final
,
type
;
if
(
parse_header
)
if
(
!
parse_zlib_header
(
a
))
return
0
;
if
(
!
stbi__
parse_zlib_header
(
a
))
return
0
;
a
->
num_bits
=
0
;
a
->
code_buffer
=
0
;
do
{
final
=
zreceive
(
a
,
1
);
type
=
zreceive
(
a
,
2
);
final
=
stbi__
zreceive
(
a
,
1
);
type
=
stbi__
zreceive
(
a
,
2
);
if
(
type
==
0
)
{
if
(
!
parse_uncompre
ssed_block
(
a
))
return
0
;
if
(
!
stbi__parse_uncomper
ssed_block
(
a
))
return
0
;
}
else
if
(
type
==
3
)
{
return
0
;
}
else
{
if
(
type
==
1
)
{
// use fixed code lengths
if
(
!
default_distance
[
31
])
init_
defaults
();
if
(
!
zbuild_huffman
(
&
a
->
z_length
,
default_length
,
288
))
return
0
;
if
(
!
zbuild_huffman
(
&
a
->
z_distance
,
default_distance
,
32
))
return
0
;
if
(
!
stbi__zdefault_distance
[
31
])
stbi__init_z
defaults
();
if
(
!
stbi__zbuild_huffman
(
&
a
->
z_length
,
stbi__z
default_length
,
288
))
return
0
;
if
(
!
stbi__zbuild_huffman
(
&
a
->
z_distance
,
stbi__z
default_distance
,
32
))
return
0
;
}
else
{
if
(
!
compute_huffman_codes
(
a
))
return
0
;
if
(
!
stbi__
compute_huffman_codes
(
a
))
return
0
;
}
if
(
!
parse_huffman_block
(
a
))
return
0
;
if
(
!
stbi__
parse_huffman_block
(
a
))
return
0
;
}
}
while
(
!
final
);
return
1
;
}
static
int
do_zlib
(
zbuf
*
a
,
char
*
obuf
,
int
olen
,
int
exp
,
int
parse_header
)
static
int
stbi__do_zlib
(
stbi__
zbuf
*
a
,
char
*
obuf
,
int
olen
,
int
exp
,
int
parse_header
)
{
a
->
zout_start
=
obuf
;
a
->
zout
=
obuf
;
a
->
zout_end
=
obuf
+
olen
;
a
->
z_expandable
=
exp
;
return
parse_zlib
(
a
,
parse_header
);
return
stbi__
parse_zlib
(
a
,
parse_header
);
}
STBIDEF
char
*
stbi_zlib_decode_malloc_guesssize
(
const
char
*
buffer
,
int
len
,
int
initial_size
,
int
*
outlen
)
{
zbuf
a
;
stbi__
zbuf
a
;
char
*
p
=
(
char
*
)
malloc
(
initial_size
);
if
(
p
==
NULL
)
return
NULL
;
a
.
zbuffer
=
(
stbi__uint8
*
)
buffer
;
a
.
zbuffer_end
=
(
stbi__uint8
*
)
buffer
+
len
;
if
(
do_zlib
(
&
a
,
p
,
initial_size
,
1
,
1
))
{
if
(
stbi__
do_zlib
(
&
a
,
p
,
initial_size
,
1
,
1
))
{
if
(
outlen
)
*
outlen
=
(
int
)
(
a
.
zout
-
a
.
zout_start
);
return
a
.
zout_start
;
}
else
{
...
...
@@ -2348,12 +2348,12 @@ STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
STBIDEF
char
*
stbi_zlib_decode_malloc_guesssize_headerflag
(
const
char
*
buffer
,
int
len
,
int
initial_size
,
int
*
outlen
,
int
parse_header
)
{
zbuf
a
;
stbi__
zbuf
a
;
char
*
p
=
(
char
*
)
malloc
(
initial_size
);
if
(
p
==
NULL
)
return
NULL
;
a
.
zbuffer
=
(
stbi__uint8
*
)
buffer
;
a
.
zbuffer_end
=
(
stbi__uint8
*
)
buffer
+
len
;
if
(
do_zlib
(
&
a
,
p
,
initial_size
,
1
,
parse_header
))
{
if
(
stbi__
do_zlib
(
&
a
,
p
,
initial_size
,
1
,
parse_header
))
{
if
(
outlen
)
*
outlen
=
(
int
)
(
a
.
zout
-
a
.
zout_start
);
return
a
.
zout_start
;
}
else
{
...
...
@@ -2364,10 +2364,10 @@ STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, i
STBIDEF
int
stbi_zlib_decode_buffer
(
char
*
obuffer
,
int
olen
,
char
const
*
ibuffer
,
int
ilen
)
{
zbuf
a
;
stbi__
zbuf
a
;
a
.
zbuffer
=
(
stbi__uint8
*
)
ibuffer
;
a
.
zbuffer_end
=
(
stbi__uint8
*
)
ibuffer
+
ilen
;
if
(
do_zlib
(
&
a
,
obuffer
,
olen
,
0
,
1
))
if
(
stbi__
do_zlib
(
&
a
,
obuffer
,
olen
,
0
,
1
))
return
(
int
)
(
a
.
zout
-
a
.
zout_start
);
else
return
-
1
;
...
...
@@ -2375,12 +2375,12 @@ STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer
STBIDEF
char
*
stbi_zlib_decode_noheader_malloc
(
char
const
*
buffer
,
int
len
,
int
*
outlen
)
{
zbuf
a
;
stbi__
zbuf
a
;
char
*
p
=
(
char
*
)
malloc
(
16384
);
if
(
p
==
NULL
)
return
NULL
;
a
.
zbuffer
=
(
stbi__uint8
*
)
buffer
;
a
.
zbuffer_end
=
(
stbi__uint8
*
)
buffer
+
len
;
if
(
do_zlib
(
&
a
,
p
,
16384
,
1
,
0
))
{
if
(
stbi__
do_zlib
(
&
a
,
p
,
16384
,
1
,
0
))
{
if
(
outlen
)
*
outlen
=
(
int
)
(
a
.
zout
-
a
.
zout_start
);
return
a
.
zout_start
;
}
else
{
...
...
@@ -2391,10 +2391,10 @@ STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int
STBIDEF
int
stbi_zlib_decode_noheader_buffer
(
char
*
obuffer
,
int
olen
,
const
char
*
ibuffer
,
int
ilen
)
{
zbuf
a
;
stbi__
zbuf
a
;
a
.
zbuffer
=
(
stbi__uint8
*
)
ibuffer
;
a
.
zbuffer_end
=
(
stbi__uint8
*
)
ibuffer
+
ilen
;
if
(
do_zlib
(
&
a
,
obuffer
,
olen
,
0
,
0
))
if
(
stbi__
do_zlib
(
&
a
,
obuffer
,
olen
,
0
,
0
))
return
(
int
)
(
a
.
zout
-
a
.
zout_start
);
else
return
-
1
;
...
...
@@ -2415,19 +2415,19 @@ typedef struct
{
stbi__uint32
length
;
stbi__uint32
type
;
}
chunk
;
}
stbi__png
chunk
;
#define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
static
chunk
get_chunk_header
(
stbi__context
*
s
)
static
stbi__pngchunk
stbi__
get_chunk_header
(
stbi__context
*
s
)
{
chunk
c
;
stbi__png
chunk
c
;
c
.
length
=
stbi__get32be
(
s
);
c
.
type
=
stbi__get32be
(
s
);
return
c
;
}
static
int
check_png_header
(
stbi__context
*
s
)
static
int
stbi__
check_png_header
(
stbi__context
*
s
)
{
static
stbi__uint8
png_sig
[
8
]
=
{
137
,
80
,
78
,
71
,
13
,
10
,
26
,
10
};
int
i
;
...
...
@@ -2440,20 +2440,20 @@ typedef struct
{
stbi__context
*
s
;
stbi__uint8
*
idata
,
*
expanded
,
*
out
;
}
png
;
}
stbi__
png
;
enum
{
F_none
=
0
,
F_sub
=
1
,
F_up
=
2
,
F_avg
=
3
,
F_paeth
=
4
,
F_avg_first
,
F_paeth_first
STBI__F_none
=
0
,
STBI__F_sub
=
1
,
STBI__F_up
=
2
,
STBI__F_avg
=
3
,
STBI__
F_paeth
=
4
,
STBI__F_avg_first
,
STBI__
F_paeth_first
};
static
stbi__uint8
first_row_filter
[
5
]
=
{
F_none
,
F_sub
,
F_none
,
F_avg_first
,
F_paeth_first
STBI__F_none
,
STBI__F_sub
,
STBI__F_none
,
STBI__F_avg_first
,
STBI__
F_paeth_first
};
static
int
paeth
(
int
a
,
int
b
,
int
c
)
static
int
stbi__
paeth
(
int
a
,
int
b
,
int
c
)
{
int
p
=
a
+
b
-
c
;
int
pa
=
abs
(
p
-
a
);
...
...
@@ -2465,7 +2465,7 @@ static int paeth(int a, int b, int c)
}
// create the png data from post-deflated data
static
int
create_png_image_raw
(
png
*
a
,
stbi__uint8
*
raw
,
stbi__uint32
raw_len
,
int
out_n
,
stbi__uint32
x
,
stbi__uint32
y
)
static
int
stbi__create_png_image_raw
(
stbi__
png
*
a
,
stbi__uint8
*
raw
,
stbi__uint32
raw_len
,
int
out_n
,
stbi__uint32
x
,
stbi__uint32
y
)
{
stbi__context
*
s
=
a
->
s
;
stbi__uint32
i
,
j
,
stride
=
x
*
out_n
;
...
...
@@ -2489,13 +2489,13 @@ static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len,
// handle first pixel explicitly
for
(
k
=
0
;
k
<
img_n
;
++
k
)
{
switch
(
filter
)
{
case
F_none
:
cur
[
k
]
=
raw
[
k
];
break
;
case
F_sub
:
cur
[
k
]
=
raw
[
k
];
break
;
case
F_up
:
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
case
F_avg
:
cur
[
k
]
=
raw
[
k
]
+
(
prior
[
k
]
>>
1
);
break
;
case
F_paeth
:
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
paeth
(
0
,
prior
[
k
],
0
));
break
;
case
F_avg_first
:
cur
[
k
]
=
raw
[
k
];
break
;
case
F_paeth_first
:
cur
[
k
]
=
raw
[
k
];
break
;
case
STBI__
F_none
:
cur
[
k
]
=
raw
[
k
];
break
;
case
STBI__
F_sub
:
cur
[
k
]
=
raw
[
k
];
break
;
case
STBI__
F_up
:
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
case
STBI__
F_avg
:
cur
[
k
]
=
raw
[
k
]
+
(
prior
[
k
]
>>
1
);
break
;
case
STBI__F_paeth
:
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
stbi__
paeth
(
0
,
prior
[
k
],
0
));
break
;
case
STBI__
F_avg_first
:
cur
[
k
]
=
raw
[
k
];
break
;
case
STBI__
F_paeth_first
:
cur
[
k
]
=
raw
[
k
];
break
;
}
}
if
(
img_n
!=
out_n
)
cur
[
img_n
]
=
255
;
...
...
@@ -2509,13 +2509,13 @@ static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len,
for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
for (k=0; k < img_n; ++k)
switch
(
filter
)
{
CASE
(
F_none
)
cur
[
k
]
=
raw
[
k
];
break
;
CASE
(
F_sub
)
cur
[
k
]
=
raw
[
k
]
+
cur
[
k
-
img_n
];
break
;
CASE
(
F_up
)
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
CASE
(
F_avg
)
cur
[
k
]
=
raw
[
k
]
+
((
prior
[
k
]
+
cur
[
k
-
img_n
])
>>
1
);
break
;
CASE
(
F_paeth
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
paeth
(
cur
[
k
-
img_n
],
prior
[
k
],
prior
[
k
-
img_n
]));
break
;
CASE
(
F_avg_first
)
cur
[
k
]
=
raw
[
k
]
+
(
cur
[
k
-
img_n
]
>>
1
);
break
;
CASE
(
F_paeth_first
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
paeth
(
cur
[
k
-
img_n
],
0
,
0
));
break
;
CASE
(
STBI__
F_none
)
cur
[
k
]
=
raw
[
k
];
break
;
CASE
(
STBI__
F_sub
)
cur
[
k
]
=
raw
[
k
]
+
cur
[
k
-
img_n
];
break
;
CASE
(
STBI__
F_up
)
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
CASE
(
STBI__
F_avg
)
cur
[
k
]
=
raw
[
k
]
+
((
prior
[
k
]
+
cur
[
k
-
img_n
])
>>
1
);
break
;
CASE
(
STBI__F_paeth
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
stbi__
paeth
(
cur
[
k
-
img_n
],
prior
[
k
],
prior
[
k
-
img_n
]));
break
;
CASE
(
STBI__
F_avg_first
)
cur
[
k
]
=
raw
[
k
]
+
(
cur
[
k
-
img_n
]
>>
1
);
break
;
CASE
(
STBI__F_paeth_first
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
stbi__
paeth
(
cur
[
k
-
img_n
],
0
,
0
));
break
;
}
#undef CASE
}
else
{
...
...
@@ -2525,13 +2525,13 @@ static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len,
for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
for (k=0; k < img_n; ++k)
switch
(
filter
)
{
CASE
(
F_none
)
cur
[
k
]
=
raw
[
k
];
break
;
CASE
(
F_sub
)
cur
[
k
]
=
raw
[
k
]
+
cur
[
k
-
out_n
];
break
;
CASE
(
F_up
)
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
CASE
(
F_avg
)
cur
[
k
]
=
raw
[
k
]
+
((
prior
[
k
]
+
cur
[
k
-
out_n
])
>>
1
);
break
;
CASE
(
F_paeth
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
paeth
(
cur
[
k
-
out_n
],
prior
[
k
],
prior
[
k
-
out_n
]));
break
;
CASE
(
F_avg_first
)
cur
[
k
]
=
raw
[
k
]
+
(
cur
[
k
-
out_n
]
>>
1
);
break
;
CASE
(
F_paeth_first
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
paeth
(
cur
[
k
-
out_n
],
0
,
0
));
break
;
CASE
(
STBI__
F_none
)
cur
[
k
]
=
raw
[
k
];
break
;
CASE
(
STBI__
F_sub
)
cur
[
k
]
=
raw
[
k
]
+
cur
[
k
-
out_n
];
break
;
CASE
(
STBI__
F_up
)
cur
[
k
]
=
raw
[
k
]
+
prior
[
k
];
break
;
CASE
(
STBI__
F_avg
)
cur
[
k
]
=
raw
[
k
]
+
((
prior
[
k
]
+
cur
[
k
-
out_n
])
>>
1
);
break
;
CASE
(
STBI__F_paeth
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
stbi__
paeth
(
cur
[
k
-
out_n
],
prior
[
k
],
prior
[
k
-
out_n
]));
break
;
CASE
(
STBI__
F_avg_first
)
cur
[
k
]
=
raw
[
k
]
+
(
cur
[
k
-
out_n
]
>>
1
);
break
;
CASE
(
STBI__F_paeth_first
)
cur
[
k
]
=
(
stbi__uint8
)
(
raw
[
k
]
+
stbi__
paeth
(
cur
[
k
-
out_n
],
0
,
0
));
break
;
}
#undef CASE
}
...
...
@@ -2539,12 +2539,12 @@ static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len,
return
1
;
}
static
int
create_png_image
(
png
*
a
,
stbi__uint8
*
raw
,
stbi__uint32
raw_len
,
int
out_n
,
int
interlaced
)
static
int
stbi__create_png_image
(
stbi__
png
*
a
,
stbi__uint8
*
raw
,
stbi__uint32
raw_len
,
int
out_n
,
int
interlaced
)
{
stbi__uint8
*
final
;
int
p
;
if
(
!
interlaced
)
return
create_png_image_raw
(
a
,
raw
,
raw_len
,
out_n
,
a
->
s
->
img_x
,
a
->
s
->
img_y
);
return
stbi__
create_png_image_raw
(
a
,
raw
,
raw_len
,
out_n
,
a
->
s
->
img_x
,
a
->
s
->
img_y
);
// de-interlacing
final
=
(
stbi__uint8
*
)
malloc
(
a
->
s
->
img_x
*
a
->
s
->
img_y
*
out_n
);
...
...
@@ -2558,7 +2558,7 @@ static int create_png_image(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int
x
=
(
a
->
s
->
img_x
-
xorig
[
p
]
+
xspc
[
p
]
-
1
)
/
xspc
[
p
];
y
=
(
a
->
s
->
img_y
-
yorig
[
p
]
+
yspc
[
p
]
-
1
)
/
yspc
[
p
];
if
(
x
&&
y
)
{
if
(
!
create_png_image_raw
(
a
,
raw
,
raw_len
,
out_n
,
x
,
y
))
{
if
(
!
stbi__
create_png_image_raw
(
a
,
raw
,
raw_len
,
out_n
,
x
,
y
))
{
free
(
final
);
return
0
;
}
...
...
@@ -2576,7 +2576,7 @@ static int create_png_image(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int
return
1
;
}
static
int
compute_transparency
(
png
*
z
,
stbi__uint8
tc
[
3
],
int
out_n
)
static
int
stbi__compute_transparency
(
stbi__
png
*
z
,
stbi__uint8
tc
[
3
],
int
out_n
)
{
stbi__context
*
s
=
z
->
s
;
stbi__uint32
i
,
pixel_count
=
s
->
img_x
*
s
->
img_y
;
...
...
@@ -2601,7 +2601,7 @@ static int compute_transparency(png *z, stbi__uint8 tc[3], int out_n)
return
1
;
}
static
int
expand_palette
(
png
*
a
,
stbi__uint8
*
palette
,
int
len
,
int
pal_img_n
)
static
int
stbi__expand_png_palette
(
stbi__
png
*
a
,
stbi__uint8
*
palette
,
int
len
,
int
pal_img_n
)
{
stbi__uint32
i
,
pixel_count
=
a
->
s
->
img_x
*
a
->
s
->
img_y
;
stbi__uint8
*
p
,
*
temp_out
,
*
orig
=
a
->
out
;
...
...
@@ -2638,19 +2638,20 @@ static int expand_palette(png *a, stbi__uint8 *palette, int len, int pal_img_n)
return
1
;
}
static
int
stbi_unpremultiply_on_load
=
0
;
static
int
stbi_de_iphone_flag
=
0
;
static
int
stbi_
_
unpremultiply_on_load
=
0
;
static
int
stbi_
_
de_iphone_flag
=
0
;
void
stbi_set_unpremultiply_on_load
(
int
flag_true_if_should_unpremultiply
)
STBIDEF
void
stbi_set_unpremultiply_on_load
(
int
flag_true_if_should_unpremultiply
)
{
stbi_unpremultiply_on_load
=
flag_true_if_should_unpremultiply
;
stbi_
_
unpremultiply_on_load
=
flag_true_if_should_unpremultiply
;
}
void
stbi_convert_iphone_png_to_rgb
(
int
flag_true_if_should_convert
)
STBIDEF
void
stbi_convert_iphone_png_to_rgb
(
int
flag_true_if_should_convert
)
{
stbi_de_iphone_flag
=
flag_true_if_should_convert
;
stbi_
_
de_iphone_flag
=
flag_true_if_should_convert
;
}
static
void
stbi_
de_iphone
(
png
*
z
)
static
void
stbi_
_de_iphone
(
stbi__
png
*
z
)
{
stbi__context
*
s
=
z
->
s
;
stbi__uint32
i
,
pixel_count
=
s
->
img_x
*
s
->
img_y
;
...
...
@@ -2665,7 +2666,7 @@ static void stbi_de_iphone(png *z)
}
}
else
{
assert
(
s
->
img_out_n
==
4
);
if
(
stbi_unpremultiply_on_load
)
{
if
(
stbi_
_
unpremultiply_on_load
)
{
// convert bgr to rgb and unpremultiply
for
(
i
=
0
;
i
<
pixel_count
;
++
i
)
{
stbi__uint8
a
=
p
[
3
];
...
...
@@ -2692,7 +2693,7 @@ static void stbi_de_iphone(png *z)
}
}
static
int
parse_png_file
(
png
*
z
,
int
scan
,
int
req_comp
)
static
int
stbi__parse_png_file
(
stbi__
png
*
z
,
int
scan
,
int
req_comp
)
{
stbi__uint8
palette
[
1024
],
pal_img_n
=
0
;
stbi__uint8
has_trans
=
0
,
tc
[
3
];
...
...
@@ -2704,15 +2705,15 @@ static int parse_png_file(png *z, int scan, int req_comp)
z
->
idata
=
NULL
;
z
->
out
=
NULL
;
if
(
!
check_png_header
(
s
))
return
0
;
if
(
!
stbi__
check_png_header
(
s
))
return
0
;
if
(
scan
==
SCAN_type
)
return
1
;
for
(;;)
{
chunk
c
=
get_chunk_header
(
s
);
stbi__pngchunk
c
=
stbi__
get_chunk_header
(
s
);
switch
(
c
.
type
)
{
case
PNG_TYPE
(
'C'
,
'g'
,
'B'
,
'I'
):
iphone
=
stbi_de_iphone_flag
;
iphone
=
stbi_
_
de_iphone_flag
;
stbi__skip
(
s
,
c
.
length
);
break
;
case
PNG_TYPE
(
'I'
,
'H'
,
'D'
,
'R'
):
{
...
...
@@ -2806,17 +2807,17 @@ static int parse_png_file(png *z, int scan, int req_comp)
s
->
img_out_n
=
s
->
img_n
+
1
;
else
s
->
img_out_n
=
s
->
img_n
;
if
(
!
create_png_image
(
z
,
z
->
expanded
,
raw_len
,
s
->
img_out_n
,
interlace
))
return
0
;
if
(
!
stbi__
create_png_image
(
z
,
z
->
expanded
,
raw_len
,
s
->
img_out_n
,
interlace
))
return
0
;
if
(
has_trans
)
if
(
!
compute_transparency
(
z
,
tc
,
s
->
img_out_n
))
return
0
;
if
(
!
stbi__
compute_transparency
(
z
,
tc
,
s
->
img_out_n
))
return
0
;
if
(
iphone
&&
s
->
img_out_n
>
2
)
stbi_de_iphone
(
z
);
stbi_
_
de_iphone
(
z
);
if
(
pal_img_n
)
{
// pal_img_n == 3 or 4
s
->
img_n
=
pal_img_n
;
// record the actual colors we had
s
->
img_out_n
=
pal_img_n
;
if
(
req_comp
>=
3
)
s
->
img_out_n
=
req_comp
;
if
(
!
expand
_palette
(
z
,
palette
,
pal_len
,
s
->
img_out_n
))
if
(
!
stbi__expand_png
_palette
(
z
,
palette
,
pal_len
,
s
->
img_out_n
))
return
0
;
}
free
(
z
->
expanded
);
z
->
expanded
=
NULL
;
...
...
@@ -2829,27 +2830,27 @@ static int parse_png_file(png *z, int scan, int req_comp)
if
((
c
.
type
&
(
1
<<
29
))
==
0
)
{
#ifndef STBI_NO_FAILURE_STRINGS
// not threadsafe
static
char
invalid_chunk
[]
=
"XXXX chunk not known"
;
static
char
invalid_chunk
[]
=
"XXXX
stbi__png
chunk not known"
;
invalid_chunk
[
0
]
=
(
stbi__uint8
)
(
c
.
type
>>
24
);
invalid_chunk
[
1
]
=
(
stbi__uint8
)
(
c
.
type
>>
16
);
invalid_chunk
[
2
]
=
(
stbi__uint8
)
(
c
.
type
>>
8
);
invalid_chunk
[
3
]
=
(
stbi__uint8
)
(
c
.
type
>>
0
);
#endif
return
stbi__err
(
invalid_chunk
,
"PNG not supported: unknown chunk type"
);
return
stbi__err
(
invalid_chunk
,
"PNG not supported: unknown
stbi__png
chunk type"
);
}
stbi__skip
(
s
,
c
.
length
);
break
;
}
// end of chunk, read and stbi__skip CRC
// end of
stbi__png
chunk, read and stbi__skip CRC
stbi__get32be
(
s
);
}
}
static
unsigned
char
*
do_png
(
png
*
p
,
int
*
x
,
int
*
y
,
int
*
n
,
int
req_comp
)
static
unsigned
char
*
stbi__do_png
(
stbi__
png
*
p
,
int
*
x
,
int
*
y
,
int
*
n
,
int
req_comp
)
{
unsigned
char
*
result
=
NULL
;
if
(
req_comp
<
0
||
req_comp
>
4
)
return
stbi__errpuc
(
"bad req_comp"
,
"Internal error"
);
if
(
parse_png_file
(
p
,
SCAN_load
,
req_comp
))
{
if
(
stbi__
parse_png_file
(
p
,
SCAN_load
,
req_comp
))
{
result
=
p
->
out
;
p
->
out
=
NULL
;
if
(
req_comp
&&
req_comp
!=
p
->
s
->
img_out_n
)
{
...
...
@@ -2870,22 +2871,22 @@ static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
static
unsigned
char
*
stbi__png_load
(
stbi__context
*
s
,
int
*
x
,
int
*
y
,
int
*
comp
,
int
req_comp
)
{
png
p
;
stbi__
png
p
;
p
.
s
=
s
;
return
do_png
(
&
p
,
x
,
y
,
comp
,
req_comp
);
return
stbi__
do_png
(
&
p
,
x
,
y
,
comp
,
req_comp
);
}
static
int
stbi__png_test
(
stbi__context
*
s
)
{
int
r
;
r
=
check_png_header
(
s
);
r
=
stbi__
check_png_header
(
s
);
stbi_rewind
(
s
);
return
r
;
}
static
int
stbi_
png_info_raw
(
png
*
p
,
int
*
x
,
int
*
y
,
int
*
comp
)
static
int
stbi_
_png_info_raw
(
stbi__
png
*
p
,
int
*
x
,
int
*
y
,
int
*
comp
)
{
if
(
!
parse_png_file
(
p
,
SCAN_header
,
0
))
{
if
(
!
stbi__
parse_png_file
(
p
,
SCAN_header
,
0
))
{
stbi_rewind
(
p
->
s
);
return
0
;
}
...
...
@@ -2895,11 +2896,11 @@ static int stbi_png_info_raw(png *p, int *x, int *y, int *comp)
return
1
;
}
static
int
stbi__png_info
(
stbi__context
*
s
,
int
*
x
,
int
*
y
,
int
*
comp
)
static
int
stbi__png_info
(
stbi__context
*
s
,
int
*
x
,
int
*
y
,
int
*
comp
)
{
png
p
;
stbi__
png
p
;
p
.
s
=
s
;
return
stbi_png_info_raw
(
&
p
,
x
,
y
,
comp
);
return
stbi_
_
png_info_raw
(
&
p
,
x
,
y
,
comp
);
}
// Microsoft/Windows BMP image
...
...
@@ -3330,7 +3331,7 @@ static stbi_uc *tga_load(stbi__context *s, int *x, int *y, int *comp, int req_co
// load the data
for
(
i
=
0
;
i
<
tga_width
*
tga_height
;
++
i
)
{
// if I'm in RLE mode, do I need to get a RLE chunk?
// if I'm in RLE mode, do I need to get a RLE
stbi__png
chunk?
if
(
tga_is_RLE
)
{
if
(
RLE_count
==
0
)
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录