eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-21 22:59:19 +02:00
Code Issues 123 Wiki Activity

reformat: parameters can be made const

Browse Source
This commit is contained in:
jerrrrycho
2026-07-04 07:08:14 +02:00
parent 6fd1d6715b
commit 220689a5e3
121 changed files with 1380 additions and 1352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
stb/stb_image.h
View File

@@ -822,7 +822,7 @@ typedef struct
static void stbi__refill_buffer(stbi__context *s);
// initialize a memory-decode context
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, const int len)
{
s->io.read = NULL;
s->read_from_callbacks = 0;
@@ -846,12 +846,12 @@ static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *
#ifndef STBI_NO_STDIO
static int stbi__stdio_read(void *user, char *data, int size)
static int stbi__stdio_read(void *user, char *data, const int size)
{
return (int) fread(data,1,size,(FILE*) user);
}
static void stbi__stdio_skip(void *user, int n)
static void stbi__stdio_skip(void *user, const int n)
{
int ch;
fseek((FILE*) user, n, SEEK_CUR);
@@ -981,7 +981,7 @@ static int stbi__err(const char *str)
}
#endif
static void *stbi__malloc(size_t size)
static void *stbi__malloc(const size_t size)
{
return STBI_MALLOC(size);
}
@@ -998,7 +998,7 @@ static void *stbi__malloc(size_t size)
// return 1 if the sum is valid, 0 on overflow.
// negative terms are considered invalid.
static int stbi__addsizes_valid(int a, int b)
static int stbi__addsizes_valid(const int a, const int b)
{
if (b < 0) return 0;
// now 0 <= b <= INT_MAX, hence also
@@ -1010,7 +1010,7 @@ static int stbi__addsizes_valid(int a, int b)
// returns 1 if the product is valid, 0 on overflow.
// negative factors are considered invalid.
static int stbi__mul2sizes_valid(int a, int b)
static int stbi__mul2sizes_valid(const int a, const int b)
{
if (a < 0 || b < 0) return 0;
if (b == 0) return 1; // mul-by-0 is always safe
@@ -1020,14 +1020,14 @@ static int stbi__mul2sizes_valid(int a, int b)
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
static int stbi__mad2sizes_valid(int a, int b, int add)
static int stbi__mad2sizes_valid(const int a, const int b, const int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
}
#endif
// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
static int stbi__mad3sizes_valid(int a, int b, int c, int add)
static int stbi__mad3sizes_valid(const int a, const int b, const int c, const int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
@@ -1035,7 +1035,7 @@ static int stbi__mad3sizes_valid(int a, int b, int c, int add)
// 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) || !defined(STBI_NO_PNM)
static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
static int stbi__mad4sizes_valid(const int a, const int b, const int c, const int d, const 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);
@@ -1044,21 +1044,21 @@ static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
// mallocs with size overflow checking
static void *stbi__malloc_mad2(int a, int b, int add)
static void *stbi__malloc_mad2(const int a, const int b, const int add)
{
if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
return stbi__malloc(a*b + add);
}
#endif
static void *stbi__malloc_mad3(int a, int b, int c, int add)
static void *stbi__malloc_mad3(const int a, const int b, const int c, const int add)
{
if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
return stbi__malloc(a*b*c + add);
}
#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
static void *stbi__malloc_mad4(const int a, const int b, const int c, const int d, const int add)
{
if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
return stbi__malloc(a*b*c*d + add);
@@ -1066,7 +1066,7 @@ static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
#endif
// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
static int stbi__addints_valid(int a, int b)
static int stbi__addints_valid(const int a, const int b)
{
if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
@@ -1074,7 +1074,7 @@ static int stbi__addints_valid(int a, int b)
}
// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
static int stbi__mul2shorts_valid(int a, int b)
static int stbi__mul2shorts_valid(const int a, const int b)
{
if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
@@ -1112,7 +1112,7 @@ static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);
static int stbi__vertically_flip_on_load_global = 0;
STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
STBIDEF void stbi_set_flip_vertically_on_load(const int flag_true_if_should_flip)
{
stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
}
@@ -1122,7 +1122,7 @@ STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
#else
static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
STBIDEF void stbi_set_flip_vertically_on_load_thread(const int flag_true_if_should_flip)
{
stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
stbi__vertically_flip_on_load_set = 1;
@@ -1133,7 +1133,7 @@ STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_fli
: stbi__vertically_flip_on_load_global)
#endif // STBI_THREAD_LOCAL
static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri, int bpc)
{
memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
@@ -1186,7 +1186,7 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
}
static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, const int w, const int h, const int channels)
{
int i;
const int img_len = w * h * channels;
@@ -1202,7 +1202,7 @@ static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int chan
return reduced;
}
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, const int w, const int h, const int channels)
{
int i;
const int img_len = w * h * channels;
@@ -1218,7 +1218,7 @@ static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int chan
return enlarged;
}
static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
static void stbi__vertical_flip(void *image, const int w, const int h, const int bytes_per_pixel)
{
int row;
const size_t bytes_per_row = (size_t)w * bytes_per_pixel;
@@ -1243,7 +1243,7 @@ static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
}
#ifndef STBI_NO_GIF
static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
static void stbi__vertical_flip_slices(void *image, const int w, const int h, const int z, const int bytes_per_pixel)
{
int slice;
const int slice_size = w * h * bytes_per_pixel;
@@ -1256,7 +1256,7 @@ static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int byt
}
#endif
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, const int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
@@ -1282,7 +1282,7 @@ static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x,
return (unsigned char *) result;
}
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, const int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
@@ -1310,7 +1310,7 @@ static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x,
}
#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)
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, const int req_comp)
{
if (stbi__vertically_flip_on_load && result != NULL) {
const int channels = req_comp ? req_comp : *comp;
@@ -1362,7 +1362,7 @@ static FILE *stbi__fopen(char const *filename, char const *mode)
}
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, const int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
unsigned char *result;
@@ -1372,7 +1372,7 @@ STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int
return result;
}
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, const int req_comp)
{
unsigned char *result;
stbi__context s;
@@ -1385,7 +1385,7 @@ STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req
return result;
}
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, const int req_comp)
{
stbi__uint16 *result;
stbi__context s;
@@ -1398,7 +1398,7 @@ STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp,
return result;
}
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, const int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
stbi__uint16 *result;
@@ -1411,28 +1411,28 @@ STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, i
#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)
STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, const int len, int *x, int *y, int *channels_in_file, const 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)
STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, const 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)
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, const int len, int *x, int *y, int *comp, const int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
}
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, const int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
@@ -1440,7 +1440,7 @@ STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *u
}
#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)
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, const int len, int **delays, int *x, int *y, int *z, int *comp, const int req_comp)
{
unsigned char *result;
stbi__context s;
@@ -1456,7 +1456,7 @@ STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int *
#endif
#ifndef STBI_NO_LINEAR
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, const int req_comp)
{
unsigned char *data;
#ifndef STBI_NO_HDR
@@ -1474,14 +1474,14 @@ static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int
return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, const int len, int *x, int *y, int *comp, const int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__loadf_main(&s,x,y,comp,req_comp);
}
STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, const int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
@@ -1489,7 +1489,7 @@ STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *us
}
#ifndef STBI_NO_STDIO
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, const int req_comp)
{
float *result;
FILE *f = stbi__fopen(filename, "rb");
@@ -1499,7 +1499,7 @@ STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int r
return result;
}
STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, const int req_comp)
{
stbi__context s;
stbi__start_file(&s,f);
@@ -1571,14 +1571,14 @@ STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void
#ifndef STBI_NO_LINEAR
static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
STBIDEF void stbi_ldr_to_hdr_gamma(const float gamma) { stbi__l2h_gamma = gamma; }
STBIDEF void stbi_ldr_to_hdr_scale(const float scale) { stbi__l2h_scale = scale; }
#endif
static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
STBIDEF void stbi_hdr_to_ldr_gamma(const float gamma) { stbi__h2l_gamma_i = 1/gamma; }
STBIDEF void stbi_hdr_to_ldr_scale(const float scale) { stbi__h2l_scale_i = 1/scale; }
//////////////////////////////////////////////////////////////////////////////
@@ -1640,7 +1640,7 @@ stbi_inline static int stbi__at_eof(stbi__context *s)
#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
// nothing
#else
static void stbi__skip(stbi__context *s, int n)
static void stbi__skip(stbi__context *s, const int n)
{
if (n == 0) return; // already there!
if (n < 0) {
@@ -1662,7 +1662,7 @@ static void stbi__skip(stbi__context *s, int n)
#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
// nothing
#else
static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
static int stbi__getn(stbi__context *s, stbi_uc *buffer, const int n)
{
if (s->io.read) {
const int blen = (int) (s->img_buffer_end - s->img_buffer);
@@ -1742,7 +1742,7 @@ static stbi__uint32 stbi__get32le(stbi__context *s)
// assume data buffer is malloced, so malloc a new one and free that one
// only failure mode is malloc failing
static stbi_uc stbi__compute_y(int r, int g, int b)
static stbi_uc stbi__compute_y(const int r, const int g, const int b)
{
return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
}
@@ -1751,7 +1751,7 @@ static stbi_uc stbi__compute_y(int r, int g, int b)
#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
// nothing
#else
static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
static unsigned char *stbi__convert_format(unsigned char *data, const int img_n, const int req_comp, const unsigned int x, const unsigned int y)
{
int i,j;
unsigned char *good;
@@ -1799,7 +1799,7 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
// nothing
#else
static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
static stbi__uint16 stbi__compute_y_16(const int r, const int g, const int b)
{
return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
}
@@ -1808,7 +1808,7 @@ static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
// nothing
#else
static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, const int img_n, const int req_comp, const unsigned int x, const unsigned int y)
{
int i,j;
stbi__uint16 *good;
@@ -1854,7 +1854,7 @@ static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int r
#endif
#ifndef STBI_NO_LINEAR
static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
static float *stbi__ldr_to_hdr(stbi_uc *data, const int x, const int y, const int comp)
{
int i,k,n;
float *output;
@@ -1880,7 +1880,7 @@ static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
#ifndef STBI_NO_HDR
#define stbi__float2int(x) ((int) (x))
static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
static stbi_uc *stbi__hdr_to_ldr(float *data, const int x, const int y, const int comp)
{
int i,k,n;
stbi_uc *output;
@@ -2149,7 +2149,7 @@ static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,
// combined JPEG 'receive' and JPEG 'extend', since baseline
// always extends everything it receives.
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, const int n)
{
unsigned int k;
int sgn;
@@ -2165,7 +2165,7 @@ stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
}
// get some unsigned bits
stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, const int n)
{
unsigned int k;
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
@@ -2206,7 +2206,7 @@ static const stbi_uc stbi__jpeg_dezigzag[64+15] =
};
// decode one 64-entry block--
static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, const int b, stbi__uint16 *dequant)
{
int diff,dc,k;
int t;
@@ -2261,7 +2261,7 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman
return 1;
}
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, const int b)
{
int diff,dc;
int t;
@@ -2412,7 +2412,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__
}
// take a -128..127 value and stbi__clamp it and convert to 0..255
stbi_inline static stbi_uc stbi__clamp(int x)
stbi_inline static stbi_uc stbi__clamp(const int x)
{
// trick to use a single test to catch both cases
if ((unsigned int) x > 255) {
@@ -3095,7 +3095,7 @@ static void stbi__jpeg_finish(stbi__jpeg *z)
}
}
static int stbi__process_marker(stbi__jpeg *z, int m)
static int stbi__process_marker(stbi__jpeg *z, const int m)
{
int L;
switch (m) {
@@ -3238,7 +3238,7 @@ static int stbi__process_scan_header(stbi__jpeg *z)
return 1;
}
static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
static int stbi__free_jpeg_components(stbi__jpeg *z, const int ncomp, const int why)
{
int i;
for (i=0; i < ncomp; ++i) {
@@ -3260,7 +3260,7 @@ static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
return why;
}
static int stbi__process_frame_header(stbi__jpeg *z, int scan)
static int stbi__process_frame_header(stbi__jpeg *z, const int scan)
{
stbi__context *s = z->s;
int Lf,p,i,q, h_max=1,v_max=1,c;
@@ -3361,7 +3361,7 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan)
#define stbi__SOF_progressive(x) ((x) == 0xc2)
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
static int stbi__decode_jpeg_header(stbi__jpeg *z, const int scan)
{
int m;
z->jfif = 0;
@@ -3452,7 +3452,7 @@ typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, const int w, const int hs)
{
STBI_NOTUSED(out);
STBI_NOTUSED(in_far);
@@ -3461,7 +3461,7 @@ static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far,
return in_near;
}
static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, const int w, const int hs)
{
// need to generate two samples vertically for every one in input
int i;
@@ -3471,7 +3471,7 @@ static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *
return out;
}
static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, const int w, const int hs)
{
// need to generate two samples horizontally for every one in input
int i;
@@ -3501,7 +3501,7 @@ static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc
#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, const int w, const int hs)
{
// need to generate 2x2 samples for every one in input
int i,t0,t1;
@@ -3642,7 +3642,7 @@ static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stb
}
#endif
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, const int w, const int hs)
{
// resample with nearest-neighbor
int i,j;
@@ -3656,7 +3656,7 @@ static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_
// this is a reduced-precision calculation of YCbCr-to-RGB introduced
// to make sure the code produces the same results in both SIMD and scalar
#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)
static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, const int count, const int step)
{
int i;
for (i=0; i < count; ++i) {
@@ -3855,13 +3855,13 @@ typedef struct
} stbi__resample;
// fast 0..255 * 0..255 => 0..255 rounded multiplication
static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
static stbi_uc stbi__blinn_8x8(const stbi_uc x, const stbi_uc y)
{
const unsigned int t = x*y + 128;
return (stbi_uc) ((t + (t >>8)) >> 8);
}
static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, const int req_comp)
{
int n, decode_n, is_rgb;
z->s->img_n = 0; // make stbi__cleanup_jpeg safe
@@ -4024,7 +4024,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp
}
}
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri)
{
unsigned char* result;
stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
@@ -4112,7 +4112,7 @@ stbi_inline static int stbi__bitreverse16(int n)
return n;
}
stbi_inline static int stbi__bit_reverse(int v, int bits)
stbi_inline static int stbi__bit_reverse(const int v, const int bits)
{
STBI_ASSERT(bits <= 16);
// to bit reverse n bits, reverse 16 and shift
@@ -4120,7 +4120,7 @@ stbi_inline static int stbi__bit_reverse(int v, int bits)
return stbi__bitreverse16(v) >> (16-bits);
}
static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, const int num)
{
int i,k=0;
int code, next_code[16], sizes[17];
@@ -4210,7 +4210,7 @@ static void stbi__fill_bits(stbi__zbuf *z)
} while (z->num_bits <= 24);
}
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, const int n)
{
unsigned int k;
if (z->num_bits < n) stbi__fill_bits(z);
@@ -4269,7 +4269,7 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
return stbi__zhuffman_decode_slowpath(a, z);
}
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
static int stbi__zexpand(stbi__zbuf *z, char *zout, const int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
@@ -4477,7 +4477,7 @@ Init algorithm:
}
*/
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
static int stbi__parse_zlib(stbi__zbuf *a, const int parse_header)
{
int final, type;
if (parse_header)
@@ -4506,7 +4506,7 @@ static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
return 1;
}
static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
static int stbi__do_zlib(stbi__zbuf *a, char *obuf, const int olen, const int exp, const int parse_header)
{
a->zout_start = obuf;
a->zout = obuf;
@@ -4516,7 +4516,7 @@ static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse
return stbi__parse_zlib(a, parse_header);
}
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, const int len, const int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
@@ -4532,12 +4532,12 @@ STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int
}
}
STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, const int len, int *outlen)
{
return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
}
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, const int len, const int initial_size, int *outlen, const int parse_header)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
@@ -4553,7 +4553,7 @@ 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)
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, const int olen, char const *ibuffer, const int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
@@ -4564,7 +4564,7 @@ STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer
return -1;
}
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, const int len, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(16384);
@@ -4580,7 +4580,7 @@ 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)
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, const int olen, const char *ibuffer, const int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
@@ -4653,7 +4653,7 @@ static stbi_uc first_row_filter[5] =
STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
};
static int stbi__paeth(int a, int b, int c)
static int stbi__paeth(const int a, const int b, const int c)
{
// This formulation looks very different from the reference in the PNG spec, but is
// actually equivalent and has favorable data dependencies and admits straightforward
@@ -4671,7 +4671,7 @@ static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,
// adds an extra all-255 alpha channel
// dest == src is legal
// img_n must be 1 or 3
static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, const stbi__uint32 x, const int img_n)
{
int i;
// must process data backwards since we allow dest==src
@@ -4692,7 +4692,7 @@ static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__ui
}
// 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)
static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, const stbi__uint32 raw_len, const int out_n, const stbi__uint32 x, const stbi__uint32 y, const int depth, const int color)
{
const int bytes = (depth == 16 ? 2 : 1);
const stbi__context *s = a->s;
@@ -4857,7 +4857,7 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r
return 1;
}
static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, const int out_n, const int depth, const int color, const int interlaced)
{
const int bytes = (depth == 16 ? 2 : 1);
const int out_bytes = out_n * bytes;
@@ -4902,7 +4902,7 @@ static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint3
return 1;
}
static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], const int out_n)
{
const stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
@@ -4927,7 +4927,7 @@ static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
return 1;
}
static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], const int out_n)
{
const stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
@@ -4952,7 +4952,7 @@ static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int ou
return 1;
}
static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, const int len, const int pal_img_n)
{
stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
stbi_uc *p, *temp_out, *orig = a->out;
@@ -4992,12 +4992,12 @@ static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int
static int stbi__unpremultiply_on_load_global = 0;
static int stbi__de_iphone_flag_global = 0;
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
STBIDEF void stbi_set_unpremultiply_on_load(const int flag_true_if_should_unpremultiply)
{
stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
}
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
STBIDEF void stbi_convert_iphone_png_to_rgb(const int flag_true_if_should_convert)
{
stbi__de_iphone_flag_global = flag_true_if_should_convert;
}
@@ -5009,13 +5009,13 @@ STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
STBIDEF void stbi_set_unpremultiply_on_load_thread(const int flag_true_if_should_unpremultiply)
{
stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
stbi__unpremultiply_on_load_set = 1;
}
STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
STBIDEF void stbi_convert_iphone_png_to_rgb_thread(const int flag_true_if_should_convert)
{
stbi__de_iphone_flag_local = flag_true_if_should_convert;
stbi__de_iphone_flag_set = 1;
@@ -5074,7 +5074,7 @@ static void stbi__de_iphone(stbi__png *z)
#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)
static int stbi__parse_png_file(stbi__png *z, const int scan, const int req_comp)
{
stbi_uc palette[1024], pal_img_n=0;
stbi_uc has_trans=0, tc[3]={0};
@@ -5257,7 +5257,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
}
}
static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, const int req_comp, stbi__result_info *ri)
{
void *result=NULL;
if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
@@ -5289,7 +5289,7 @@ static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, st
return result;
}
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri)
{
stbi__png p;
p.s = s;
@@ -5389,7 +5389,7 @@ static int stbi__bitcount(unsigned int a)
// 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 int stbi__shiftsigned(unsigned int v, const int shift, const int bits)
{
static unsigned int mul_table[9] = {
0,
@@ -5416,7 +5416,7 @@ typedef struct
int extra_read;
} stbi__bmp_data;
static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, const int compress)
{
// BI_BITFIELDS specifies masks explicitly, don't override
if (compress == 3)
@@ -5733,7 +5733,7 @@ static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req
// by Jonathan Dummer
#ifndef STBI_NO_TGA
// returns STBI_rgb or whatever, 0 on error
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
static int stbi__tga_get_comp(const int bits_per_pixel, const int is_grey, int* is_rgb16)
{
// only RGB or RGBA (incl. 16bit) or grey allowed
if (is_rgb16) *is_rgb16 = 0;
@@ -5865,7 +5865,7 @@ static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
// so let's treat all 15 and 16bit TGAs as RGB with no alpha.
}
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri)
{
// read in the TGA header stuff
const int tga_offset = stbi__get8(s);
@@ -6082,7 +6082,7 @@ static int stbi__psd_test(stbi__context *s)
return r;
}
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, const int pixelCount)
{
int count, nleft, len;
@@ -6120,7 +6120,7 @@ static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
return 1;
}
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri, const int bpc)
{
int pixelCount;
int channelCount, compression;
@@ -6361,7 +6361,7 @@ typedef struct
stbi_uc size,type,channel;
} stbi__pic_packet;
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
static stbi_uc *stbi__readval(stbi__context *s, const int channel, stbi_uc *dest)
{
int mask=0x80, i;
@@ -6375,7 +6375,7 @@ static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
return dest;
}
static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
static void stbi__copyval(const int channel,stbi_uc *dest,const stbi_uc *src)
{
int mask=0x80,i;
@@ -6384,7 +6384,7 @@ static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
dest[i]=src[i];
}
static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
static stbi_uc *stbi__pic_load_core(stbi__context *s, const int width, const int height,int *comp, stbi_uc *result)
{
int act_comp=0,num_packets=0,y,chained;
stbi__pic_packet packets[10];
@@ -6591,7 +6591,7 @@ static int stbi__gif_test(stbi__context *s)
return r;
}
static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], const int num_entries, const int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
@@ -6602,7 +6602,7 @@ static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], in
}
}
static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, const int is_info)
{
stbi_uc version;
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
@@ -6648,7 +6648,7 @@ static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
return 1;
}
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
static void stbi__out_gif_code(stbi__gif *g, const stbi__uint16 code)
{
stbi_uc *p, *c;
int idx;
@@ -6772,7 +6772,7 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
// this function is designed to support animated gifs, although stb_image doesn't support it
// 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)
static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, const int req_comp, stbi_uc *two_back)
{
int dispose;
int first_frame;
@@ -6957,7 +6957,7 @@ static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **dela
return stbi__errpuc("outofmem", "Out of memory");
}
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, const int req_comp)
{
if (stbi__gif_test(s)) {
int layers = 0;
@@ -7042,7 +7042,7 @@ static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y,
}
}
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri)
{
stbi_uc *u = 0;
stbi__gif g;
@@ -7125,7 +7125,7 @@ static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
return buffer;
}
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
static void stbi__hdr_convert(float *output, stbi_uc *input, const int req_comp)
{
if ( input[3] != 0 ) {
float f1;
@@ -7500,7 +7500,7 @@ static int stbi__pnm_test(stbi__context *s)
return 1;
}
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, const int req_comp, stbi__result_info *ri)
{
stbi_uc *out;
STBI_NOTUSED(ri);
@@ -7537,7 +7537,7 @@ static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req
return out;
}
static int stbi__pnm_isspace(char c)
static int stbi__pnm_isspace(const char c)
{
return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
}
@@ -7556,7 +7556,7 @@ static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
}
}
static int stbi__pnm_isdigit(char c)
static int stbi__pnm_isdigit(const char c)
{
return c >= '0' && c <= '9';
}
@@ -7730,7 +7730,7 @@ STBIDEF int stbi_is_16_bit_from_file(FILE *f)
}
#endif // !STBI_NO_STDIO
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, const int len, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
@@ -7744,7 +7744,7 @@ STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int
return stbi__info_main(&s,x,y,comp);
}
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, const int len)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);

61
stb/stb_image_write.h
View File

@@ -258,7 +258,7 @@ int stbi_write_force_png_filter = -1;
static int stbi__flip_vertically_on_write = 0;
STBIWDEF void stbi_flip_vertically_on_write(int flag)
STBIWDEF void stbi_flip_vertically_on_write(const int flag)
{
stbi__flip_vertically_on_write = flag;
}
@@ -280,7 +280,7 @@ static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func
#ifndef STBI_WRITE_NO_STDIO
static void stbi__stdio_write(void *context, void *data, int size)
static void stbi__stdio_write(void *context, void *data, const int size)
{
fwrite(data,1,size,(FILE*) context);
}
@@ -397,14 +397,14 @@ static void stbiw__putc(stbi__write_context *s, unsigned char c)
s->func(s->context, &c, 1);
}
static void stbiw__write1(stbi__write_context *s, unsigned char a)
static void stbiw__write1(stbi__write_context *s, const unsigned char a)
{
if (s->buf_used + 1 > sizeof(s->buffer))
stbiw__write_flush(s);
s->buffer[s->buf_used++] = a;
}
static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
static void stbiw__write3(stbi__write_context *s, const unsigned char a, const unsigned char b, const unsigned char c)
{
int n;
if (s->buf_used + 3 > sizeof(s->buffer))
@@ -416,7 +416,7 @@ static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char
s->buffer[n+2] = c;
}
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
static void stbiw__write_pixel(stbi__write_context *s, const int rgb_dir, const int comp, const int write_alpha, const int expand_mono, unsigned char *d)
{
unsigned char bg[3] = { 255, 0, 255}, px[3];
int k;
@@ -449,7 +449,8 @@ static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, in
stbiw__write1(s, d[comp - 1]);
}
static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
static void stbiw__write_pixels(stbi__write_context *s, const int rgb_dir, int vdir, const int x, const int y, const int comp, void *data, const int write_alpha, const int scanline_pad,
const int expand_mono)
{
stbiw_uint32 zero = 0;
int i,j, j_end;
@@ -476,7 +477,7 @@ static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, i
}
}
static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
static int stbiw__outfile(stbi__write_context *s, const int rgb_dir, const int vdir, const int x, const int y, const int comp, const int expand_mono, void *data, const int alpha, const int pad, const char *fmt, ...)
{
if (y < 0 || x < 0) {
return 0;
@@ -490,7 +491,7 @@ static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x,
}
}
static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
static int stbi_write_bmp_core(stbi__write_context *s, const int x, const int y, const int comp, const void *data)
{
const int pad = (-x*3) & 3;
return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
@@ -499,7 +500,7 @@ static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, c
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
}
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, const int x, const int y, const int comp, const void *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
@@ -507,7 +508,7 @@ STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x,
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
STBIWDEF int stbi_write_bmp(char const *filename, const int x, const int y, const int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
@@ -519,7 +520,7 @@ STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const
}
#endif //!STBI_WRITE_NO_STDIO
static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)
static int stbi_write_tga_core(stbi__write_context *s, const int x, const int y, const int comp, void *data)
{
const int has_alpha = (comp == 2 || comp == 4);
const int colorbytes = has_alpha ? comp-1 : comp;
@@ -598,7 +599,7 @@ static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, v
return 1;
}
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, const int x, const int y, const int comp, const void *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
@@ -606,7 +607,7 @@ STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x,
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
STBIWDEF int stbi_write_tga(char const *filename, const int x, const int y, const int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
@@ -641,7 +642,7 @@ static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
}
}
static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
static void stbiw__write_run_data(stbi__write_context *s, const int length, unsigned char databyte)
{
unsigned char lengthbyte = STBIW_UCHAR(length+128);
STBIW_ASSERT(length+128 <= 255);
@@ -649,7 +650,7 @@ static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned c
s->func(s->context, &databyte, 1);
}
static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
static void stbiw__write_dump_data(stbi__write_context *s, const int length, unsigned char *data)
{
unsigned char lengthbyte = STBIW_UCHAR(length);
STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
@@ -657,7 +658,7 @@ static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned
s->func(s->context, data, length);
}
static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
static void stbiw__write_hdr_scanline(stbi__write_context *s, const int width, const int ncomp, unsigned char *scratch, float *scanline)
{
unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
unsigned char rgbe[4];
@@ -746,7 +747,7 @@ static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int nco
}
}
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
static int stbi_write_hdr_core(stbi__write_context *s, const int x, const int y, const int comp, float *data)
{
if (y <= 0 || x <= 0 || data == NULL)
return 0;
@@ -772,7 +773,7 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, f
}
}
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, const int x, const int y, const int comp, const float *data)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
@@ -780,7 +781,7 @@ STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x,
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
STBIWDEF int stbi_write_hdr(char const *filename, const int x, const int y, const int comp, const float *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
@@ -812,7 +813,7 @@ STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const
#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)
#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
static void *stbiw__sbgrowf(void **arr, const int increment, const int itemsize)
{
const int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
@@ -845,7 +846,7 @@ static int stbiw__zlib_bitrev(int code, int codebits)
return res;
}
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, const int limit)
{
int i;
for (i=0; i < limit && i < 258; ++i)
@@ -1046,13 +1047,13 @@ static unsigned int stbiw__crc32(unsigned char *buffer, int len)
#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
static void stbiw__wpcrc(unsigned char **data, int len)
static void stbiw__wpcrc(unsigned char **data, const int len)
{
const unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
stbiw__wp32(*data, crc);
}
static unsigned char stbiw__paeth(int a, int b, int c)
static unsigned char stbiw__paeth(const int a, const int b, const int c)
{
int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
@@ -1061,7 +1062,7 @@ static unsigned char stbiw__paeth(int a, int b, int c)
}
// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer)
static void stbiw__encode_png_line(unsigned char *pixels, const int stride_bytes, const int width, const int height, const int y, const int n, const int filter_type, signed char *line_buffer)
{
static int mapping[] = { 0,1,2,3,4 };
static int firstmap[] = { 0,1,0,5,6 };
@@ -1097,7 +1098,7 @@ static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int
}
}
STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, const int x, const int y, const int n, int *out_len)
{
int force_filter = stbi_write_force_png_filter;
const int ctype[5] = { -1, 0, 4, 2, 6 };
@@ -1184,7 +1185,7 @@ STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int s
}
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
STBIWDEF int stbi_write_png(char const *filename, const int x, const int y, const int comp, const void *data, const int stride_bytes)
{
FILE *f;
int len;
@@ -1200,7 +1201,7 @@ STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const
}
#endif
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, const int x, const int y, const int comp, const void *data, const int stride_bytes)
{
int len;
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
@@ -1297,7 +1298,7 @@ static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
bits[0] = val & ((1<<bits[1])-1);
}
static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, const int du_stride, float *fdtbl, const int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
int dataOff, i, j, n, diff, end0pos, x, y;
@@ -1576,7 +1577,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
return 1;
}
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, const int x, const int y, const int comp, const void *data, const int quality)
{
stbi__write_context s = { 0 };
stbi__start_write_callbacks(&s, func, context);
@@ -1585,7 +1586,7 @@ STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x,
#ifndef STBI_WRITE_NO_STDIO
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
STBIWDEF int stbi_write_jpg(char const *filename, const int x, const int y, const int comp, const void *data, const int quality)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {