[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemacs-commit] qemacs stb_image.h
|
From: |
Charlie Gordon |
|
Subject: |
[Qemacs-commit] qemacs stb_image.h |
|
Date: |
Wed, 27 Mar 2019 03:16:05 -0400 (EDT) |
CVSROOT: /sources/qemacs
Module name: qemacs
Changes by: Charlie Gordon <chqrlie> 19/03/27 03:16:05
Modified files:
. : stb_image.h
Log message:
update stb_image.h
- upgrade from version 2.15 to version 2.22
- add support for 16-bit png and 1-bit BMP
- this fixes the crash bug on tests/tiger.bmp
- change sbti__shiftsigned to avoid clang -O2 bug
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/qemacs/stb_image.h?cvsroot=qemacs&r1=1.2&r2=1.3
Patches:
Index: stb_image.h
===================================================================
RCS file: /sources/qemacs/qemacs/stb_image.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- stb_image.h 9 Apr 2018 14:36:41 -0000 1.2
+++ stb_image.h 27 Mar 2019 07:16:05 -0000 1.3
@@ -1,4 +1,4 @@
-/* stb_image - v2.15 - public domain image loader -
http://nothings.org/stb_image.h
+/* stb_image - v2.22 - public domain image loader - http://nothings.org/stb
no warranty implied; use at your own risk
Do this:
@@ -48,6 +48,13 @@
RECENT REVISION HISTORY:
+ 2.22 (2019-03-04) gif fixes, fix warnings
+ 2.21 (2019-02-25) fix typo in comment
+ 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and
platform ifdefs
+ 2.19 (2018-02-11) fix warning
+ 2.18 (2018-01-30) fix warnings
+ 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+ 2.16 (2017-07-23) all functions have 16-bit variants; optimizations;
bugfixes
2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE
detection on GCC
2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet
JPGs
2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
@@ -58,10 +65,6 @@
correct channel count for PNG & BMP
2.10 (2016-01-22) avoid warning introduced in 2.09
2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
- 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
- 2.07 (2015-09-13) partial animated GIF support
- limited 16-bit PSD support
- minor bugs, code cleanup, and compiler warnings
See end of file for full revision history.
@@ -77,28 +80,31 @@
Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)
Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)
github:urraka (animated gif) Junggon Kim (PNM comments)
- Daniel Gibson (16-bit TGA)
+ Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)
socks-the-fox (16-bit PNG)
Jeremy Sawicki (handle all ImageNet
JPGs)
- Optimizations & bugfixes
- Fabian "ryg" Giesen
+ Optimizations & bugfixes Mikhail Morozov (1-bit BMP)
+ Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query)
Arseny Kapoulkine
+ John-Mark Allen
+ Carmelo J Fdez-Aguera
Bug & warning fixes
Marc LeBlanc David Woo Guillaume George Martins
Mozeiko
Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan
Dave Moore Roy Eltham Hayaki Saito Nathan Reed
Won Chun Luke Graham Johan Duparc Nick
Verigakis
- the Horde3D community Thomas Ruf Ronny Chevalier Baldur
Karlsson
- Janez Zemva John Bartholomew Michal Cichon github:rlyeh
- Jonathan Blow Ken Hamada Tero Hanninen
github:romigrou
- Laurent Gomila Cort Stratton Sergio Gonzalez github:svdijk
- Aruelien Pocheville Thibault Reuille Cass Everitt github:snagar
- Ryamond Barbiero Paul Du Bois Engin Manap github:Zelex
- address@hidden Philipp Wiesemann Dale Weiler github:grim210
- Oriol Ferrer Mesia Josh Tobin Matthew Gregan
github:sammyhw
- Blazej Dariusz Roszkowski Gregory Mullen github:phprus
-
+ the Horde3D community Thomas Ruf Ronny Chevalier github:rlyeh
+ Janez Zemva John Bartholomew Michal Cichon
github:romigrou
+ Jonathan Blow Ken Hamada Tero Hanninen github:svdijk
+ Laurent Gomila Cort Stratton Sergio Gonzalez github:snagar
+ Aruelien Pocheville Thibault Reuille Cass Everitt github:Zelex
+ Ryamond Barbiero Paul Du Bois Engin Manap
github:grim210
+ Aldo Culquicondor Philipp Wiesemann Dale Weiler
github:sammyhw
+ Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:phprus
+ Julian Raschke Gregory Mullen Baldur Karlsson
github:poppolopoppo
+ Christian Floisand Kevin Schmidt JR Smith
github:darealshinji
+ Blazej Dariusz Roszkowski
github:Michaelangel007
*/
#ifndef STBI_INCLUDE_STB_IMAGE_H
@@ -107,10 +113,8 @@
// DOCUMENTATION
//
// Limitations:
-// - no 16-bit-per-channel PNG
// - no 12-bit-per-channel JPEG
// - no JPEGs with arithmetic coding
-// - no 1-bit BMP
// - GIF always returns *comp=4
//
// Basic usage (see HDR discussion below for HDR usage):
@@ -134,11 +138,12 @@
// with each pixel consisting of N interleaved 8-bit components; the first
// pixel pointed to is top-left-most in the image. There is no padding between
// image scanlines or between pixels, regardless of format. The number of
-// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
-// If req_comp is non-zero, *comp has the number of components that _would_
-// have been output otherwise. E.g. if you set req_comp to 4, you will always
-// get RGBA output, but you can check *comp to see if it's trivially opaque
-// because e.g. there were only 3 channels in the source image.
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's
trivially
+// opaque because e.g. there were only 3 channels in the source image.
//
// An output image with N components has the following components interleaved
// in this order in each pixel:
@@ -150,16 +155,26 @@
// 4 red, green, blue, alpha
//
// If image loading fails for any reason, the return value will be NULL,
-// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
-// can be queried for an extremely brief, end-user unfriendly explanation
-// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
-// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define
STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get
slightly
// more user-friendly ones.
//
// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
//
// ===========================================================================
//
+// UNICODE:
+//
+// If compiling for Windows and you wish to use Unicode filenames, compile
+// with
+// #define STBI_WINDOWS_UTF8
+// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to
convert
+// Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
// Philosophy
//
// stb libraries are designed with the following priorities:
@@ -170,12 +185,12 @@
//
// Sometimes I let "good performance" creep up in priority over "easy to
maintain",
// and for best performance I may provide less-easy-to-use APIs that give
higher
-// performance, in addition to the easy to use ones. Nevertheless, it's
important
+// performance, in addition to the easy-to-use ones. Nevertheless, it's
important
// to keep in mind that from the standpoint of you, a client of this library,
// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3
above all.
//
// Some secondary priorities arise directly from the first two, some of which
-// make more explicit reasons why performance can't be emphasized.
+// provide more explicit reasons why performance can't be emphasized.
//
// - Portable ("ease of use")
// - Small source code footprint ("easy to maintain")
@@ -218,11 +233,10 @@
//
// HDR image support (disable by defining STBI_NO_HDR)
//
-// stb_image now supports loading HDR images in general, and currently
-// the Radiance .HDR file format, although the support is provided
-// generically. You can still load any file through the existing interface;
-// if you attempt to load an HDR file, it will be automatically remapped to
-// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the
existing
+// interface; if you attempt to load an HDR file, it will be automatically
remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
// both of these constants can be reconfigured through this interface:
//
// stbi_hdr_to_ldr_gamma(2.2f);
@@ -256,7 +270,7 @@
//
// By default we convert iphone-formatted PNGs back to RGB, even though
// they are internally encoded differently. You can disable this conversion
-// by by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
// you will always just get the native iphone "format" through (which
// is BGR stored in RGB).
//
@@ -310,7 +324,7 @@
enum
{
- STBI_default = 0, // only used for req_comp
+ STBI_default = 0, // only used for desired_channels
STBI_grey = 1,
STBI_grey_alpha = 2,
@@ -318,6 +332,7 @@
STBI_rgb_alpha = 4
};
+#include <stdlib.h>
typedef unsigned char stbi_uc;
typedef unsigned short stbi_us;
@@ -325,11 +340,13 @@
extern "C" {
#endif
+#ifndef STBIDEF
#ifdef STB_IMAGE_STATIC
#define STBIDEF static
#else
#define STBIDEF extern
#endif
+#endif
//////////////////////////////////////////////////////////////////////////////
//
@@ -352,36 +369,46 @@
// 8-bits-per-channel interface
//
-STBIDEF stbi_uc *stbi_load (char const *filename,
int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int
len , int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk ,
void *user, int *x, int *y, int *channels_in_file, int desired_channels);
#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y,
int *channels_in_file, int desired_channels);
STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int
*channels_in_file, int desired_channels);
// for stbi_load_from_file, file pointer is left pointing immediately after
image
#endif
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int
**delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const
wchar_t* input);
+#endif
+
////////////////////////////////////
//
// 16-bits-per-channel interface
//
-STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int
*channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len,
int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk,
void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y,
int *channels_in_file, int desired_channels);
STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int
*channels_in_file, int desired_channels);
#endif
-// @TODO the other variants
////////////////////////////////////
//
// float-per-channel interface
//
#ifndef STBI_NO_LINEAR
- STBIDEF float *stbi_loadf (char const *filename,
int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len,
int *x, int *y, int *channels_in_file, int desired_channels);
STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk,
void *user, int *x, int *y, int *channels_in_file, int desired_channels);
#ifndef STBI_NO_STDIO
+ STBIDEF float *stbi_loadf (char const *filename, int *x, int *y,
int *channels_in_file, int desired_channels);
STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int
*channels_in_file, int desired_channels);
#endif
#endif
@@ -415,11 +442,14 @@
// get image dimensions & components without fully decoding
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x,
int *y, int *comp);
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void
*user, int *x, int *y, int *comp);
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk,
void *user);
#ifndef STBI_NO_STDIO
STBIDEF int stbi_info (char const *filename, int *x, int
*y, int *comp);
STBIDEF int stbi_info_from_file (FILE *f, int *x, int
*y, int *comp);
-
+STBIDEF int stbi_is_16_bit (char const *filename);
+STBIDEF int stbi_is_16_bit_from_file(FILE *f);
#endif
@@ -503,7 +533,7 @@
#include <limits.h>
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
-#include <math.h> // ldexp
+#include <math.h> // ldexp, pow
#endif
#ifndef STBI_NO_STDIO
@@ -515,6 +545,12 @@
#define STBI_ASSERT(x) assert(x)
#endif
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
#ifndef _MSC_VER
#ifdef __cplusplus
@@ -639,14 +675,18 @@
#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
static int stbi__sse2_available(void)
{
int info3 = stbi__cpuid3();
return ((info3 >> 26) & 1) != 0;
}
+#endif
+
#else // assume GCC-style if not VC++
#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
static int stbi__sse2_available(void)
{
// If we're even attempting to compile this on GCC/Clang, that means
@@ -655,6 +695,8 @@
return 1;
}
#endif
+
+#endif
#endif
// ARM NEON
@@ -783,6 +825,7 @@
static int stbi__png_test(stbi__context *s);
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp,
int req_comp, stbi__result_info *ri);
static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__png_is16(stbi__context *s);
#endif
#ifndef STBI_NO_BMP
@@ -801,6 +844,7 @@
static int stbi__psd_test(stbi__context *s);
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp,
int req_comp, stbi__result_info *ri, int bpc);
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int stbi__psd_is16(stbi__context *s);
#endif
#ifndef STBI_NO_HDR
@@ -818,6 +862,7 @@
#ifndef STBI_NO_GIF
static int stbi__gif_test(stbi__context *s);
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp,
int req_comp, stbi__result_info *ri);
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x,
int *y, int *z, int *comp, int req_comp);
static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
#endif
@@ -892,11 +937,13 @@
}
// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't
overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
}
+#endif
// mallocs with size overflow checking
static void *stbi__malloc_mad2(int a, int b, int add)
@@ -911,11 +958,13 @@
return stbi__malloc(a*b*c + add);
}
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
{
if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
return stbi__malloc(a*b*c*d + add);
}
+#endif
// stbi__err - error
// stbi__errpf - error returning pointer to float
@@ -1029,6 +1078,44 @@
return enlarged;
}
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+ int row;
+ size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+ stbi_uc temp[2048];
+ stbi_uc *bytes = (stbi_uc *)image;
+
+ for (row = 0; row < (h>>1); row++) {
+ stbi_uc *row0 = bytes + row*bytes_per_row;
+ stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+ // swap row0 with row1
+ size_t bytes_left = bytes_per_row;
+ while (bytes_left) {
+ size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left :
sizeof(temp);
+ memcpy(temp, row0, bytes_copy);
+ memcpy(row0, row1, bytes_copy);
+ memcpy(row1, temp, bytes_copy);
+ row0 += bytes_copy;
+ row1 += bytes_copy;
+ bytes_left -= bytes_copy;
+ }
+ }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int
bytes_per_pixel)
+{
+ int slice;
+ int slice_size = w * h * bytes_per_pixel;
+
+ stbi_uc *bytes = (stbi_uc *)image;
+ for (slice = 0; slice < z; ++slice) {
+ stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+ bytes += slice_size;
+ }
+}
+#endif
+
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int
*x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
@@ -1046,21 +1133,8 @@
// @TODO: move stbi__convert_format to here
if (stbi__vertically_flip_on_load) {
- int w = *x, h = *y;
int channels = req_comp ? req_comp : *comp;
- int row,col,z;
- stbi_uc *image = (stbi_uc *) result;
-
- // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
- for (row = 0; row < (h>>1); row++) {
- for (col = 0; col < w; col++) {
- for (z = 0; z < channels; z++) {
- stbi_uc temp = image[(row * w + col) * channels + z];
- image[(row * w + col) * channels + z] = image[((h - row - 1) *
w + col) * channels + z];
- image[((h - row - 1) * w + col) * channels + z] = temp;
- }
- }
- }
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
}
return (unsigned char *) result;
@@ -1084,55 +1158,57 @@
// @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case
to keep more precision
if (stbi__vertically_flip_on_load) {
- int w = *x, h = *y;
int channels = req_comp ? req_comp : *comp;
- int row,col,z;
- stbi__uint16 *image = (stbi__uint16 *) result;
-
- // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
- for (row = 0; row < (h>>1); row++) {
- for (col = 0; col < w; col++) {
- for (z = 0; z < channels; z++) {
- stbi__uint16 temp = image[(row * w + col) * channels + z];
- image[(row * w + col) * channels + z] = image[((h - row - 1) *
w + col) * channels + z];
- image[((h - row - 1) * w + col) * channels + z] = temp;
- }
- }
- }
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
}
return (stbi__uint16 *) result;
}
-#ifndef STBI_NO_HDR
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp,
int req_comp)
{
if (stbi__vertically_flip_on_load && result != NULL) {
- int w = *x, h = *y;
- int depth = req_comp ? req_comp : *comp;
- int row,col,z;
- float temp;
-
- // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
- for (row = 0; row < (h>>1); row++) {
- for (col = 0; col < w; col++) {
- for (z = 0; z < depth; z++) {
- temp = result[(row * w + col) * depth + z];
- result[(row * w + col) * depth + z] = result[((h - row - 1) * w
+ col) * depth + z];
- result[((h - row - 1) * w + col) * depth + z] = temp;
- }
- }
- }
+ int channels = req_comp ? req_comp : *comp;
+ stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
}
}
#endif
#ifndef STBI_NO_STDIO
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned
int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int
cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned
int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str,
int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const
wchar_t* input)
+{
+ return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer,
(int) bufferlen, NULL, NULL);
+}
+#endif
+
static FILE *stbi__fopen(char const *filename, char const *mode)
{
FILE *f;
-#if defined(_MSC_VER) && _MSC_VER >= 1400
+#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
+ wchar_t wMode[64];
+ wchar_t wFilename[1024];
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1,
wFilename, sizeof(wFilename)))
+ return 0;
+
+ if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode,
sizeof(wMode)))
+ return 0;
+
+#if _MSC_VER >= 1400
+ if (0 != _wfopen_s(&f, wFilename, wMode))
+ f = 0;
+#else
+ f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
if (0 != fopen_s(&f, filename, mode))
f=0;
#else
@@ -1191,6 +1267,20 @@
#endif //!STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int
*x, int *y, int *channels_in_file, int desired_channels)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return
stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk,
void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+ return
stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x,
int *y, int *comp, int req_comp)
{
stbi__context s;
@@ -1205,6 +1295,22 @@
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
}
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int
**delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+ unsigned char *result;
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+
+ result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp,
req_comp);
+ if (stbi__vertically_flip_on_load) {
+ stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
+ }
+
+ return result;
+}
+#endif
+
#ifndef STBI_NO_LINEAR
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp,
int req_comp)
{
@@ -1291,9 +1397,13 @@
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
#ifndef STBI_NO_HDR
+ long pos = ftell(f);
+ int res;
stbi__context s;
stbi__start_file(&s,f);
- return stbi__hdr_test(&s);
+ res = stbi__hdr_test(&s);
+ fseek(f, pos, SEEK_SET);
+ return res;
#else
STBI_NOTUSED(f);
return 0;
@@ -1491,18 +1601,18 @@
// convert source image with img_n components to one with req_comp
components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
- STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255;
} break;
+ STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;
} break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];
} break;
- STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255;
} break;
+ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;
} break;
STBI__CASE(2,1) { dest[0]=src[0];
} break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];
} break;
- STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];
} break;
- STBI__CASE(3,4) {
dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; } break;
+ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];
} break;
+ STBI__CASE(3,4) {
dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);
} break;
- STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]),
dest[1] = 255; } break;
+ STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);
dest[1] = 255; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);
} break;
- STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]),
dest[1] = src[3]; } break;
- STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];
} break;
+ STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);
dest[1] = src[3]; } break;
+ STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];
} break;
default: STBI_ASSERT(0);
}
#undef STBI__CASE
@@ -1540,18 +1650,18 @@
// convert source image with img_n components to one with req_comp
components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
- STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff;
} break;
+ STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;
} break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];
} break;
- STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff;
} break;
+ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;
} break;
STBI__CASE(2,1) { dest[0]=src[0];
} break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];
} break;
- STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];
} break;
- STBI__CASE(3,4) {
dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; } break;
+ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];
} break;
+ STBI__CASE(3,4) {
dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);
} break;
- STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]),
dest[1] = 0xffff; } break;
+ STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);
dest[1] = 0xffff; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);
} break;
- STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]),
dest[1] = src[3]; } break;
- STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];
} break;
+ STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);
dest[1] = src[3]; } break;
+ STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];
} break;
default: STBI_ASSERT(0);
}
#undef STBI__CASE
@@ -1575,7 +1685,11 @@
for (k=0; k < n; ++k) {
output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f,
stbi__l2h_gamma) * stbi__l2h_scale);
}
- if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+ }
+ if (n < comp) {
+ for (i=0; i < x*y; ++i) {
+ output[i*comp + n] = data[i*comp + n]/255.0f;
+ }
}
STBI_FREE(data);
return output;
@@ -1705,7 +1819,8 @@
static int stbi__build_huffman(stbi__huffman *h, int *count)
{
- int i,j,k=0,code;
+ int i,j,k=0;
+ unsigned int code;
// build size list for each symbol (from JPEG spec)
for (i=0; i < 16; ++i)
for (j=0; j < count[i]; ++j)
@@ -1721,7 +1836,7 @@
if (h->size[k] == j) {
while (h->size[k] == j)
h->code[k++] = (stbi__uint16) (code++);
- if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt
JPEG");
+ if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt
JPEG");
}
// compute largest code + 1 for this size, preshifted as needed later
h->maxcode[j] = code << (16-j);
@@ -1765,7 +1880,7 @@
if (k < m) k += (~0U << magbits) + 1;
// if the result is small enough, we can fit it in fast_ac table
if (k >= -128 && k <= 127)
- fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len +
magbits));
+ fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len +
magbits));
}
}
}
@@ -1774,7 +1889,7 @@
static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
do {
- int b = j->nomore ? 0 : stbi__get8(j->s);
+ unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
if (b == 0xff) {
int c = stbi__get8(j->s);
while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
@@ -1790,7 +1905,7 @@
}
// (1 << n) - 1
-static stbi__uint32
stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+static const stbi__uint32
stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
// decode a jpeg huffman value from the bitstream
stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
@@ -1843,7 +1958,7 @@
}
// bias[n] = (-1<<n) + 1
-static int const stbi__jbias[16] =
{0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+static const int stbi__jbias[16] =
{0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
// combined JPEG 'receive' and JPEG 'extend', since baseline
// always extends everything it receives.
@@ -1886,7 +2001,7 @@
// given a value that's at position X in the zigzag stream,
// where does it appear in the 8x8 matrix coded as row-major?
-static stbi_uc stbi__jpeg_dezigzag[64+15] =
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
{
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
@@ -2112,7 +2227,7 @@
}
#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))
-#define stbi__fsh(x) ((x) << 12)
+#define stbi__fsh(x) ((x) * 4096)
// derived from jidctint -- DCT_ISLOW
#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
@@ -2167,7 +2282,7 @@
// (1|2|3|4|5|6|7)==0 0 seconds
// all separate -0.047 seconds
// 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
- int dcterm = d[0] << 2;
+ int dcterm = d[0]*4;
v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
} else {
STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
@@ -2806,7 +2921,7 @@
if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
for (i=0; i < 64; ++i)
- z->dequant[t][stbi__jpeg_dezigzag[i]] = sixteen ?
stbi__get16be(z->s) : stbi__get8(z->s);
+ z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen
? stbi__get16be(z->s) : stbi__get8(z->s));
L -= (sixteen ? 129 : 65);
}
return L==0;
@@ -2968,7 +3083,7 @@
z->rgb = 0;
for (i=0; i < s->img_n; ++i) {
- static unsigned char rgb[3] = { 'R', 'G', 'B' };
+ static const unsigned char rgb[3] = { 'R', 'G', 'B' };
z->img_comp[i].id = stbi__get8(s);
if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
++z->rgb;
@@ -3093,8 +3208,8 @@
} else if (stbi__DNL(m)) {
int Ld = stbi__get16be(j->s);
stbi__uint32 NL = stbi__get16be(j->s);
- if (Ld != 4) stbi__err("bad DNL len", "Corrupt JPEG");
- if (NL != j->s->img_y) stbi__err("bad DNL height", "Corrupt JPEG");
+ if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+ if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt
JPEG");
} else {
if (!stbi__process_marker(j, m)) return 0;
}
@@ -3547,7 +3662,7 @@
int k;
unsigned int i,j;
stbi_uc *output;
- stbi_uc *coutput[4];
+ stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
stbi__resample res_comp[4];
@@ -3611,20 +3726,20 @@
} else if (z->s->img_n == 4) {
if (z->app14_color_transform == 0) { // CMYK
for (i=0; i < z->s->img_x; ++i) {
- stbi_uc k = coutput[3][i];
- out[0] = stbi__blinn_8x8(coutput[0][i], k);
- out[1] = stbi__blinn_8x8(coutput[1][i], k);
- out[2] = stbi__blinn_8x8(coutput[2][i], k);
+ stbi_uc m = coutput[3][i];
+ out[0] = stbi__blinn_8x8(coutput[0][i], m);
+ out[1] = stbi__blinn_8x8(coutput[1][i], m);
+ out[2] = stbi__blinn_8x8(coutput[2][i], m);
out[3] = 255;
out += n;
}
} else if (z->app14_color_transform == 2) { // YCCK
z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2],
z->s->img_x, n);
for (i=0; i < z->s->img_x; ++i) {
- stbi_uc k = coutput[3][i];
- out[0] = stbi__blinn_8x8(255 - out[0], k);
- out[1] = stbi__blinn_8x8(255 - out[1], k);
- out[2] = stbi__blinn_8x8(255 - out[2], k);
+ stbi_uc m = coutput[3][i];
+ out[0] = stbi__blinn_8x8(255 - out[0], m);
+ out[1] = stbi__blinn_8x8(255 - out[1], m);
+ out[2] = stbi__blinn_8x8(255 - out[2], m);
out += n;
}
} else { // YCbCr + alpha? Ignore the fourth channel for now
@@ -3649,10 +3764,10 @@
}
} else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
for (i=0; i < z->s->img_x; ++i) {
- stbi_uc k = coutput[3][i];
- stbi_uc r = stbi__blinn_8x8(coutput[0][i], k);
- stbi_uc g = stbi__blinn_8x8(coutput[1][i], k);
- stbi_uc b = stbi__blinn_8x8(coutput[2][i], k);
+ stbi_uc m = coutput[3][i];
+ stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+ stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+ stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
out[0] = stbi__compute_y(r, g, b);
out[1] = 255;
out += n;
@@ -3668,7 +3783,7 @@
if (n == 1)
for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
else
- for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+ for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ =
255; }
}
}
}
@@ -3912,18 +4027,18 @@
return 1;
}
-static int stbi__zlength_base[31] = {
+static const int stbi__zlength_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 stbi__zlength_extra[31]=
+static const int stbi__zlength_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 stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+static const int stbi__zdist_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 stbi__zdist_extra[32] =
+static const int stbi__zdist_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 stbi__parse_huffman_block(stbi__zbuf *a)
@@ -3970,7 +4085,7 @@
static int stbi__compute_huffman_codes(stbi__zbuf *a)
{
- static stbi_uc length_dezigzag[19] = {
16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+ static const stbi_uc length_dezigzag[19] = {
16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
stbi__zhuffman z_codelength;
stbi_uc lencodes[286+32+137];//padding for maximum single op
stbi_uc codelength_sizes[19];
@@ -4229,7 +4344,7 @@
static int stbi__check_png_header(stbi__context *s)
{
- static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+ static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
int i;
for (i=0; i < 8; ++i)
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a
PNG");
@@ -4275,7 +4390,7 @@
return c;
}
-static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0,
0x01 };
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11,
0,0,0, 0x01 };
// create the png data from post-deflated data
static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32
raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
@@ -4295,13 +4410,14 @@
a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra
bytes to write off the end into
if (!a->out) return stbi__err("outofmem", "Out of memory");
+ if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too
large", "Corrupt PNG");
img_width_bytes = (((img_n * x * depth) + 7) >> 3);
img_len = (img_width_bytes + 1) * y;
- if (s->img_x == x && s->img_y == y) {
- if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt
PNG");
- } else { // interlaced:
+
+ // we used to check for exact match between raw_len and img_len on
non-interlaced PNGs,
+ // but issue #276 reported a PNG in the wild that had extra data at the end
(all zeros),
+ // so just check for raw_len < img_len always.
if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt
PNG");
- }
for (j=0; j < y; ++j) {
stbi_uc *cur = a->out + stride*j;
@@ -4654,9 +4770,10 @@
stbi_uc a = p[3];
stbi_uc t = p[0];
if (a) {
- p[0] = p[2] * 255 / a;
- p[1] = p[1] * 255 / a;
- p[2] = t * 255 / a;
+ stbi_uc half = a / 2;
+ p[0] = (p[2] * 255 + half) / a;
+ p[1] = (p[1] * 255 + half) / a;
+ p[2] = ( t * 255 + half) / a;
} else {
p[0] = p[2];
p[2] = t;
@@ -4675,12 +4792,12 @@
}
}
-#define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) <<
16) + ((unsigned) (c) << 8) + (unsigned) (d))
static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
{
stbi_uc palette[1024], pal_img_n=0;
- stbi_uc has_trans=0, tc[3];
+ stbi_uc has_trans=0, tc[3]={0};
stbi__uint16 tc16[3];
stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
int first=1,k,interlace=0, color=0, is_iphone=0;
@@ -4819,6 +4936,9 @@
if (req_comp >= 3) s->img_out_n = req_comp;
if (!stbi__expand_png_palette(z, palette, pal_len,
s->img_out_n))
return 0;
+ } else if (has_trans) {
+ // non-paletted image with tRNS -> source image has (constant)
alpha
+ ++s->img_n;
}
STBI_FREE(z->expanded); z->expanded = NULL;
return 1;
@@ -4909,6 +5029,19 @@
p.s = s;
return stbi__png_info_raw(&p, x, y, comp);
}
+
+static int stbi__png_is16(stbi__context *s)
+{
+ stbi__png p;
+ p.s = s;
+ if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+ return 0;
+ if (p.depth != 16) {
+ stbi__rewind(p.s);
+ return 0;
+ }
+ return 1;
+}
#endif
// Microsoft/Windows BMP image
@@ -4942,11 +5075,11 @@
{
int n=0;
if (z == 0) return -1;
- if (z >= 0x10000) n += 16, z >>= 16;
- if (z >= 0x00100) n += 8, z >>= 8;
- if (z >= 0x00010) n += 4, z >>= 4;
- if (z >= 0x00004) n += 2, z >>= 2;
- if (z >= 0x00002) n += 1, z >>= 1;
+ if (z >= 0x10000) { n += 16; z >>= 16; }
+ if (z >= 0x00100) { n += 8; z >>= 8; }
+ if (z >= 0x00010) { n += 4; z >>= 4; }
+ if (z >= 0x00004) { n += 2; z >>= 2; }
+ if (z >= 0x00002) { n += 1; z >>= 1; }
return n;
}
@@ -4960,21 +5093,27 @@
return a & 0xff;
}
-static int stbi__shiftsigned(int v, int shift, int bits)
-{
- int result;
- int z=0;
-
- if (shift < 0) v <<= -shift;
- else v >>= shift;
- result = v;
-
- z = bits;
- while (z < 8) {
- result += v >> z;
- z += bits;
- }
- return result;
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+ static unsigned int mul_table[9] = {
+ 0,
+ 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/,
0x11/*0b00010001*/,
+ 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/,
0x01/*0b00000001*/,
+ };
+ static unsigned int shift_table[9] = {
+ 0, 0,0,1,0,2,4,6,0,
+ };
+ if (shift < 0)
+ v <<= -shift;
+ else
+ v >>= shift;
+ STBI_ASSERT(v >= 0 && v < 256);
+ v >>= (8-bits);
+ STBI_ASSERT(bits >= 0 && bits <= 8);
+ return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
}
typedef struct
@@ -5004,7 +5143,6 @@
}
if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
info->bpp = stbi__get16le(s);
- if (info->bpp == 1) return stbi__errpuc("monochrome", "BMP type not
supported: 1-bit");
if (hsz != 12) {
int compress = stbi__get32le(s);
if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP
type not supported: RLE");
@@ -5122,10 +5260,29 @@
pal[i][3] = 255;
}
stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3
: 4));
- if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+ if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+ else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
else if (info.bpp == 8) width = s->img_x;
else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
pad = (-width)&3;
+ if (info.bpp == 1) {
+ for (j=0; j < (int) s->img_y; ++j) {
+ int bit_offset = 7, v = stbi__get8(s);
+ for (i=0; i < (int) s->img_x; ++i) {
+ int color = (v>>bit_offset)&0x1;
+ out[z++] = pal[color][0];
+ out[z++] = pal[color][1];
+ out[z++] = pal[color][2];
+ if (target == 4) out[z++] = 255;
+ if (i+1 == (int) s->img_x) break;
+ if((--bit_offset) < 0) {
+ bit_offset = 7;
+ v = stbi__get8(s);
+ }
+ }
+ stbi__skip(s, pad);
+ }
+ } else {
for (j=0; j < (int) s->img_y; ++j) {
for (i=0; i < (int) s->img_x; i += 2) {
int v=stbi__get8(s),v2=0;
@@ -5146,6 +5303,7 @@
}
stbi__skip(s, pad);
}
+ }
} else {
int
rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
int z = 0;
@@ -5185,7 +5343,7 @@
int bpp = info.bpp;
for (i=0; i < (int) s->img_x; ++i) {
stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) :
stbi__get32le(s));
- int a;
+ unsigned int a;
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift,
rcount));
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift,
gcount));
out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift,
bcount));
@@ -5209,7 +5367,7 @@
stbi_uc *p1 = out + j *s->img_x*target;
stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
for (i=0; i < (int) s->img_x*target; ++i) {
- t = p1[i], p1[i] = p2[i], p2[i] = t;
+ t = p1[i]; p1[i] = p2[i]; p2[i] = t;
}
}
}
@@ -5233,14 +5391,14 @@
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
{
// only RGB or RGBA (incl. 16bit) or grey allowed
- if(is_rgb16) *is_rgb16 = 0;
+ if (is_rgb16) *is_rgb16 = 0;
switch(bits_per_pixel) {
case 8: return STBI_grey;
case 16: if(is_grey) return STBI_grey_alpha;
- // else: fall-through
+ // fallthrough
case 15: if(is_rgb16) *is_rgb16 = 1;
return STBI_rgb;
- case 24: // fall-through
+ case 24: // fallthrough
case 32: return bits_per_pixel/8;
default: return 0;
}
@@ -5699,7 +5857,7 @@
// Else if n is 128, noop.
// Endloop
- // The RLE-compressed data is preceeded by a 2-byte data count for each
row in the data,
+ // The RLE-compressed data is preceded by a 2-byte data count for each
row in the data,
// which we're going to just skip.
stbi__skip(s, h * channelCount * 2 );
@@ -6035,11 +6193,13 @@
typedef struct
{
int w,h;
- stbi_uc *out, *old_out; // output buffer (always 4 components)
- int flags, bgindex, ratio, transparent, eflags, delay;
+ stbi_uc *out; // output buffer (always 4 components)
+ stbi_uc *background; // The current "background" as far as a gif
is concerned
+ stbi_uc *history;
+ int flags, bgindex, ratio, transparent, eflags;
stbi_uc pal[256][4];
stbi_uc lpal[256][4];
- stbi__gif_lzw codes[4096];
+ stbi__gif_lzw codes[8192];
stbi_uc *color_table;
int parse, step;
int lflags;
@@ -6047,6 +6207,7 @@
int max_x, max_y;
int cur_x, cur_y;
int line_size;
+ int delay;
} stbi__gif;
static int stbi__gif_test_raw(stbi__context *s)
@@ -6122,6 +6283,7 @@
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
stbi_uc *p, *c;
+ int idx;
// recurse to decode the prefixes, since the linked-list is backwards,
// and working backwards through an interleaved image would be nasty
@@ -6130,10 +6292,12 @@
if (g->cur_y >= g->max_y) return;
- p = &g->out[g->cur_x + g->cur_y];
- c = &g->color_table[g->codes[code].suffix * 4];
+ idx = g->cur_x + g->cur_y;
+ p = &g->out[idx];
+ g->history[idx / 4] = 1;
- if (c[3] >= 128) {
+ c = &g->color_table[g->codes[code].suffix * 4];
+ if (c[3] > 128) { // don't render transparent pixels;
p[0] = c[2];
p[1] = c[1];
p[2] = c[0];
@@ -6207,11 +6371,16 @@
stbi__skip(s,len);
return g->out;
} else if (code <= avail) {
- if (first) return stbi__errpuc("no clear code", "Corrupt GIF");
+ if (first) {
+ return stbi__errpuc("no clear code", "Corrupt GIF");
+ }
if (oldcode >= 0) {
p = &g->codes[avail++];
- if (avail > 4096) return stbi__errpuc("too many codes",
"Corrupt GIF");
+ if (avail > 8192) {
+ return stbi__errpuc("too many codes", "Corrupt GIF");
+ }
+
p->prefix = (stbi__int16) oldcode;
p->first = g->codes[oldcode].first;
p->suffix = (code == avail) ? p->first : g->codes[code].first;
@@ -6233,62 +6402,77 @@
}
}
-static void stbi__fill_gif_background(stbi__gif *g, int x0, int y0, int x1,
int y1)
-{
- int x, y;
- stbi_uc *c = g->pal[g->bgindex];
- for (y = y0; y < y1; y += 4 * g->w) {
- for (x = x0; x < x1; x += 4) {
- stbi_uc *p = &g->out[y + x];
- p[0] = c[2];
- p[1] = c[1];
- p[2] = c[0];
- p[3] = 0;
- }
- }
-}
-
// this function is designed to support animated gifs, although stb_image
doesn't support it
-static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp,
int req_comp)
+// two back is the image from two frames ago, used for a very specific
disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp,
int req_comp, stbi_uc *two_back)
{
- int i;
- stbi_uc *prev_out = 0;
+ int dispose;
+ int first_frame;
+ int pi;
+ int pcount;
+ STBI_NOTUSED(req_comp);
- if (g->out == 0 && !stbi__gif_header(s, g, comp,0))
- return 0; // stbi__g_failure_reason set by stbi__gif_header
+ // on first frame, any non-written pixels get the background colour
(non-transparent)
+ first_frame = 0;
+ if (g->out == 0) {
+ if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason
set by stbi__gif_header
+ if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+ return stbi__errpuc("too large", "GIF image is too large");
+ pcount = g->w * g->h;
+ g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+ g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+ g->history = (stbi_uc *) stbi__malloc(pcount);
+ if (!g->out || !g->background || !g->history)
+ return stbi__errpuc("outofmem", "Out of memory");
- if (!stbi__mad3sizes_valid(g->w, g->h, 4, 0))
- return stbi__errpuc("too large", "GIF too large");
+ // image is treated as "transparent" at the start - ie, nothing
overwrites the current background;
+ // background colour is only used for pixels that are not rendered first
frame, after that "background"
+ // color refers to the color that was there the previous frame.
+ memset(g->out, 0x00, 4 * pcount);
+ memset(g->background, 0x00, 4 * pcount); // state of the background
(starts transparent)
+ memset(g->history, 0x00, pcount); // pixels that were affected
previous frame
+ first_frame = 1;
+ } else {
+ // second frame - how do we dispoase of the previous one?
+ dispose = (g->eflags & 0x1C) >> 2;
+ pcount = g->w * g->h;
- prev_out = g->out;
- g->out = (stbi_uc *) stbi__malloc_mad3(4, g->w, g->h, 0);
- if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory");
+ if ((dispose == 3) && (two_back == 0)) {
+ dispose = 2; // if I don't have an image to revert back to, default
to the old background
+ }
- switch ((g->eflags & 0x1C) >> 2) {
- case 0: // unspecified (also always used on 1st frame)
- stbi__fill_gif_background(g, 0, 0, 4 * g->w, 4 * g->w * g->h);
- break;
- case 1: // do not dispose
- if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h);
- g->old_out = prev_out;
- break;
- case 2: // dispose to background
- if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h);
- stbi__fill_gif_background(g, g->start_x, g->start_y, g->max_x,
g->max_y);
- break;
- case 3: // dispose to previous
- if (g->old_out) {
- for (i = g->start_y; i < g->max_y; i += 4 * g->w)
- memcpy(&g->out[i + g->start_x], &g->old_out[i + g->start_x],
g->max_x - g->start_x);
+ if (dispose == 3) { // use previous graphic
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi]) {
+ memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
}
- break;
}
+ } else if (dispose == 2) {
+ // restore what was changed last frame to background before that
frame;
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi]) {
+ memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
+ }
+ }
+ } else {
+ // This is a non-disposal case eithe way, so just
+ // leave the pixels as is, and they will become the new background
+ // 1: do not dispose
+ // 0: not specified.
+ }
+
+ // background is what out is after the undoing of the previou frame;
+ memcpy( g->background, g->out, 4 * g->w * g->h );
+ }
+
+ // clear my history;
+ memset( g->history, 0x00, g->w * g->h ); // pixels that were
affected previous frame
for (;;) {
- switch (stbi__get8(s)) {
+ int tag = stbi__get8(s);
+ switch (tag) {
case 0x2C: /* Image Descriptor */
{
- int prev_trans = -1;
stbi__int32 x, y, w, h;
stbi_uc *o;
@@ -6307,6 +6491,13 @@
g->cur_x = g->start_x;
g->cur_y = g->start_y;
+ // if the width of the specified rectangle is 0, that means
+ // we may not see *any* pixels or the image is malformed;
+ // to make sure this is caught, move the current y down to
+ // max_y (which is what out_gif_code checks).
+ if (w == 0)
+ g->cur_y = g->max_y;
+
g->lflags = stbi__get8(s);
if (g->lflags & 0x40) {
@@ -6321,19 +6512,24 @@
stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7),
g->eflags & 0x01 ? g->transparent : -1);
g->color_table = (stbi_uc *) g->lpal;
} else if (g->flags & 0x80) {
- if (g->transparent >= 0 && (g->eflags & 0x01)) {
- prev_trans = g->pal[g->transparent][3];
- g->pal[g->transparent][3] = 0;
- }
g->color_table = (stbi_uc *) g->pal;
} else
return stbi__errpuc("missing color table", "Corrupt GIF");
o = stbi__process_gif_raster(s, g);
- if (o == NULL) return NULL;
+ if (!o) return NULL;
- if (prev_trans != -1)
- g->pal[g->transparent][3] = (stbi_uc) prev_trans;
+ // if this was the first frame,
+ pcount = g->w * g->h;
+ if (first_frame && (g->bgindex > 0)) {
+ // if first frame, any pixel not drawn to gets the background
color
+ for (pi = 0; pi < pcount; ++pi) {
+ if (g->history[pi] == 0) {
+ g->pal[g->bgindex][3] = 255; // just in case it was made
transparent, undo that; It will be reset next frame if need be;
+ memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
+ }
+ }
+ }
return o;
}
@@ -6341,19 +6537,35 @@
case 0x21: // Comment Extension.
{
int len;
- if (stbi__get8(s) == 0xF9) { // Graphic Control Extension.
+ int ext = stbi__get8(s);
+ if (ext == 0xF9) { // Graphic Control Extension.
len = stbi__get8(s);
if (len == 4) {
g->eflags = stbi__get8(s);
- g->delay = stbi__get16le(s);
+ g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a
second, saving as 1/1000ths.
+
+ // unset old transparent
+ if (g->transparent >= 0) {
+ g->pal[g->transparent][3] = 255;
+ }
+ if (g->eflags & 0x01) {
g->transparent = stbi__get8(s);
+ if (g->transparent >= 0) {
+ g->pal[g->transparent][3] = 0;
+ }
+ } else {
+ // don't need transparent
+ stbi__skip(s, 1);
+ g->transparent = -1;
+ }
} else {
stbi__skip(s, len);
break;
}
}
- while ((len = stbi__get8(s)) != 0)
+ while ((len = stbi__get8(s)) != 0) {
stbi__skip(s, len);
+ }
break;
}
@@ -6364,28 +6576,96 @@
return stbi__errpuc("unknown code", "Corrupt GIF");
}
}
+}
- STBI_NOTUSED(req_comp);
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int
*y, int *z, int *comp, int req_comp)
+{
+ if (stbi__gif_test(s)) {
+ int layers = 0;
+ stbi_uc *u = 0;
+ stbi_uc *out = 0;
+ stbi_uc *two_back = 0;
+ stbi__gif g;
+ int stride;
+ memset(&g, 0, sizeof(g));
+ if (delays) {
+ *delays = 0;
+ }
+
+ do {
+ u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+ if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
+
+ if (u) {
+ *x = g.w;
+ *y = g.h;
+ ++layers;
+ stride = g.w * g.h * 4;
+
+ if (out) {
+ out = (stbi_uc*) STBI_REALLOC( out, layers * stride );
+ if (delays) {
+ *delays = (int*) STBI_REALLOC( *delays, sizeof(int) * layers
);
+ }
+ } else {
+ out = (stbi_uc*)stbi__malloc( layers * stride );
+ if (delays) {
+ *delays = (int*) stbi__malloc( layers * sizeof(int) );
+ }
+ }
+ memcpy( out + ((layers - 1) * stride), u, stride );
+ if (layers >= 2) {
+ two_back = out - 2 * stride;
+ }
+
+ if (delays) {
+ (*delays)[layers - 1U] = g.delay;
+ }
+ }
+ } while (u != 0);
+
+ // free temp buffer;
+ STBI_FREE(g.out);
+ STBI_FREE(g.history);
+ STBI_FREE(g.background);
+
+ // do the final conversion after loading everything;
+ if (req_comp && req_comp != 4)
+ out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+ *z = layers;
+ return out;
+ } else {
+ return stbi__errpuc("not GIF", "Image was not as a gif type.");
+ }
}
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int
req_comp, stbi__result_info *ri)
{
stbi_uc *u = 0;
- stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
- memset(g, 0, sizeof(*g));
+ stbi__gif g;
+ memset(&g, 0, sizeof(g));
STBI_NOTUSED(ri);
- u = stbi__gif_load_next(s, g, comp, req_comp);
+ u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
if (u == (stbi_uc *) s) u = 0; // end of animated gif marker
if (u) {
- *x = g->w;
- *y = g->h;
+ *x = g.w;
+ *y = g.h;
+
+ // moved conversion to after successful load so that the same
+ // can be done for multiple frames.
if (req_comp && req_comp != 4)
- u = stbi__convert_format(u, 4, req_comp, g->w, g->h);
+ u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+ } else if (g.out) {
+ // if there was an error and we allocated an image buffer, free it!
+ STBI_FREE(g.out);
}
- else if (g->out)
- STBI_FREE(g->out);
- STBI_FREE(g);
+
+ // free buffers needed for multiple frame loading;
+ STBI_FREE(g.history);
+ STBI_FREE(g.background);
+
return u;
}
@@ -6664,7 +6944,7 @@
#ifndef STBI_NO_PSD
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
- int channelCount, dummy;
+ int channelCount, dummy, depth;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
@@ -6684,7 +6964,8 @@
}
*y = stbi__get32be(s);
*x = stbi__get32be(s);
- if (stbi__get16be(s) != 8) {
+ depth = stbi__get16be(s);
+ if (depth != 8 && depth != 16) {
stbi__rewind( s );
return 0;
}
@@ -6695,6 +6976,33 @@
*comp = 4;
return 1;
}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+ int channelCount, depth;
+ if (stbi__get32be(s) != 0x38425053) {
+ stbi__rewind( s );
+ return 0;
+ }
+ if (stbi__get16be(s) != 1) {
+ stbi__rewind( s );
+ return 0;
+ }
+ stbi__skip(s, 6);
+ channelCount = stbi__get16be(s);
+ if (channelCount < 0 || channelCount > 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ (void) stbi__get32be(s);
+ (void) stbi__get32be(s);
+ depth = stbi__get16be(s);
+ if (depth != 16) {
+ stbi__rewind( s );
+ return 0;
+ }
+ return 1;
+}
#endif
#ifndef STBI_NO_PIC
@@ -6925,6 +7233,19 @@
return stbi__err("unknown image type", "Image not of any known type, or
corrupt");
}
+static int stbi__is_16_main(stbi__context *s)
+{
+ #ifndef STBI_NO_PNG
+ if (stbi__png_is16(s)) return 1;
+ #endif
+
+ #ifndef STBI_NO_PSD
+ if (stbi__psd_is16(s)) return 1;
+ #endif
+
+ return 0;
+}
+
#ifndef STBI_NO_STDIO
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
@@ -6946,6 +7267,27 @@
fseek(f,pos,SEEK_SET);
return r;
}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+ FILE *f = stbi__fopen(filename, "rb");
+ int result;
+ if (!f) return stbi__err("can't fopen", "Unable to open file");
+ result = stbi_is_16_bit_from_file(f);
+ fclose(f);
+ return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+ int r;
+ stbi__context s;
+ long pos = ftell(f);
+ stbi__start_file(&s, f);
+ r = stbi__is_16_main(&s);
+ fseek(f,pos,SEEK_SET);
+ return r;
+}
#endif // !STBI_NO_STDIO
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int
*y, int *comp)
@@ -6962,10 +7304,38 @@
return stbi__info_main(&s,x,y,comp);
}
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+ stbi__context s;
+ stbi__start_mem(&s,buffer,len);
+ return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void
*user)
+{
+ stbi__context s;
+ stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+ return stbi__is_16_main(&s);
+}
+
#endif // STB_IMAGE_IMPLEMENTATION
/*
revision history:
+ 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and
platform ifdefs
+ 2.19 (2018-02-11) fix warning
+ 2.18 (2018-01-30) fix warnings
+ 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+ 1-bit BMP
+ *_is_16_bit api
+ avoid warnings
+ 2.16 (2017-07-23) all functions have 16-bit variants;
+ STBI_NO_STDIO works again;
+ compilation fixes;
+ fix rounding in unpremultiply;
+ optimize vertical flip;
+ disable raw_len validation;
+ documentation fixes
2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
warning fixes; disable run-time SSE detection on gcc;
uniform handling of optional "return" values;
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Qemacs-commit] qemacs stb_image.h,
Charlie Gordon <=