|
|
@@ -1,4 +1,4 @@
|
|
|
-/* stb_image_write - v1.07 - public domain - http://nothings.org/stb/stb_image_write.h
|
|
|
+/* stb_image_write - v1.08 - public domain - http://nothings.org/stb/stb_image_write.h
|
|
|
writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
|
|
|
no warranty implied; use at your own risk
|
|
|
|
|
|
@@ -10,34 +10,47 @@
|
|
|
|
|
|
Will probably not work correctly with strict-aliasing optimizations.
|
|
|
|
|
|
+ If using a modern Microsoft Compiler, non-safe versions of CRT calls may cause
|
|
|
+ compilation warnings or even errors. To avoid this, also before #including,
|
|
|
+
|
|
|
+ #define STBI_MSC_SECURE_CRT
|
|
|
+
|
|
|
ABOUT:
|
|
|
|
|
|
This header file is a library for writing images to C stdio. It could be
|
|
|
adapted to write to memory or a general streaming interface; let me know.
|
|
|
|
|
|
The PNG output is not optimal; it is 20-50% larger than the file
|
|
|
- written by a decent optimizing implementation. This library is designed
|
|
|
- for source code compactness and simplicity, not optimal image file size
|
|
|
- or run-time performance.
|
|
|
+ written by a decent optimizing implementation; though providing a custom
|
|
|
+ zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.
|
|
|
+ This library is designed for source code compactness and simplicity,
|
|
|
+ not optimal image file size or run-time performance.
|
|
|
|
|
|
BUILDING:
|
|
|
|
|
|
You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.
|
|
|
You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace
|
|
|
malloc,realloc,free.
|
|
|
- You can define STBIW_MEMMOVE() to replace memmove()
|
|
|
+ You can #define STBIW_MEMMOVE() to replace memmove()
|
|
|
+ You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function
|
|
|
+ for PNG compression (instead of the builtin one), it must have the following signature:
|
|
|
+ unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);
|
|
|
+ The returned data will be freed with STBIW_FREE() (free() by default),
|
|
|
+ so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
|
|
|
|
|
|
USAGE:
|
|
|
|
|
|
- There are four functions, one for each image file format:
|
|
|
+ There are five functions, one for each image file format:
|
|
|
|
|
|
int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
|
|
|
int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
|
|
|
int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
|
|
|
int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
|
|
|
- int stbi_write_jpg(char const *filename, int w, int h, int comp, const float *data);
|
|
|
+ int stbi_write_jpg(char const *filename, int w, int h, int comp, const float *data, int quality);
|
|
|
|
|
|
- There are also four equivalent functions that use an arbitrary write function. You are
|
|
|
+ void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
|
|
|
+
|
|
|
+ There are also five equivalent functions that use an arbitrary write function. You are
|
|
|
expected to open/close your file-equivalent before and after calling these:
|
|
|
|
|
|
int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes);
|
|
|
@@ -49,6 +62,12 @@ USAGE:
|
|
|
where the callback is:
|
|
|
void stbi_write_func(void *context, void *data, int size);
|
|
|
|
|
|
+ You can configure it with these global variables:
|
|
|
+ int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE
|
|
|
+ int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression
|
|
|
+ int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode
|
|
|
+
|
|
|
+
|
|
|
You can define STBI_WRITE_NO_STDIO to disable the file variant of these
|
|
|
functions, so the library will not use stdio.h at all. However, this will
|
|
|
also disable HDR writing, because it requires stdio for formatted output.
|
|
|
@@ -75,6 +94,9 @@ USAGE:
|
|
|
writer, both because it is in BGR order and because it may have padding
|
|
|
at the end of the line.)
|
|
|
|
|
|
+ PNG allows you to set the deflate compression level by setting the global
|
|
|
+ variable 'stbi_write_png_level' (it defaults to 8).
|
|
|
+
|
|
|
HDR expects linear float data. Since the format is always 32-bit rgb(e)
|
|
|
data, alpha (if provided) is discarded, and for monochrome data it is
|
|
|
replicated across all three channels.
|
|
|
@@ -88,21 +110,17 @@ USAGE:
|
|
|
|
|
|
CREDITS:
|
|
|
|
|
|
- PNG/BMP/TGA
|
|
|
- Sean Barrett
|
|
|
- HDR
|
|
|
- Baldur Karlsson
|
|
|
- TGA monochrome:
|
|
|
- Jean-Sebastien Guay
|
|
|
- misc enhancements:
|
|
|
- Tim Kelsey
|
|
|
- TGA RLE
|
|
|
- Alan Hickman
|
|
|
- initial file IO callback implementation
|
|
|
- Emmanuel Julien
|
|
|
- JPEG
|
|
|
- Jon Olick (original jo_jpeg.cpp code)
|
|
|
- Daniel Gibson
|
|
|
+
|
|
|
+ Sean Barrett - PNG/BMP/TGA
|
|
|
+ Baldur Karlsson - HDR
|
|
|
+ Jean-Sebastien Guay - TGA monochrome
|
|
|
+ Tim Kelsey - misc enhancements
|
|
|
+ Alan Hickman - TGA RLE
|
|
|
+ Emmanuel Julien - initial file IO callback implementation
|
|
|
+ Jon Olick - original jo_jpeg.cpp code
|
|
|
+ Daniel Gibson - integrate JPEG, allow external zlib
|
|
|
+ Aarni Koskela - allow choosing PNG filter
|
|
|
+
|
|
|
bugfixes:
|
|
|
github:Chribba
|
|
|
Guillaume Chereau
|
|
|
@@ -114,6 +132,7 @@ CREDITS:
|
|
|
Thatcher Ulrich
|
|
|
github:poppolopoppo
|
|
|
Patrick Boettcher
|
|
|
+ github:xeekworx
|
|
|
|
|
|
LICENSE
|
|
|
|
|
|
@@ -132,9 +151,12 @@ extern "C" {
|
|
|
#define STBIWDEF static
|
|
|
#else
|
|
|
#define STBIWDEF extern
|
|
|
-extern int stbi_write_tga_with_rle;
|
|
|
#endif
|
|
|
|
|
|
+STBIWDEF int stbi_write_tga_with_rle;
|
|
|
+STBIWDEF int stbi_write_png_comperssion_level;
|
|
|
+STBIWDEF int stbi_write_force_png_filter;
|
|
|
+
|
|
|
#ifndef STBI_WRITE_NO_STDIO
|
|
|
STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
|
|
|
STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
|
|
|
@@ -151,6 +173,8 @@ STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w,
|
|
|
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
|
|
|
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 void stbi_flip_vertically_on_write(int flip_boolean);
|
|
|
+
|
|
|
#ifdef __cplusplus
|
|
|
}
|
|
|
#endif
|
|
|
@@ -208,6 +232,23 @@ STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x,
|
|
|
|
|
|
#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
|
|
|
|
|
|
+#ifdef STB_IMAGE_WRITE_STATIC
|
|
|
+static stbi__flip_vertically_on_write=0;
|
|
|
+static int stbi_write_png_compression level = 8;
|
|
|
+static int stbi_write_tga_with_rle = 1;
|
|
|
+static int stbi_write_force_png_filter = -1;
|
|
|
+#else
|
|
|
+int stbi_write_png_compression_level = 8;
|
|
|
+int stbi__flip_vertically_on_write=0;
|
|
|
+int stbi_write_tga_with_rle = 1;
|
|
|
+int stbi_write_force_png_filter = -1;
|
|
|
+#endif
|
|
|
+
|
|
|
+STBIWDEF void stbi_flip_vertically_on_write(int flag)
|
|
|
+{
|
|
|
+ stbi__flip_vertically_on_write = flag;
|
|
|
+}
|
|
|
+
|
|
|
typedef struct
|
|
|
{
|
|
|
stbi_write_func *func;
|
|
|
@@ -230,7 +271,13 @@ static void stbi__stdio_write(void *context, void *data, int size)
|
|
|
|
|
|
static int stbi__start_write_file(stbi__write_context *s, const char *filename)
|
|
|
{
|
|
|
- FILE *f = fopen(filename, "wb");
|
|
|
+ FILE *f;
|
|
|
+#ifdef STBI_MSC_SECURE_CRT
|
|
|
+ if (fopen_s(&f, filename, "wb"))
|
|
|
+ f = NULL;
|
|
|
+#else
|
|
|
+ f = fopen(filename, "wb");
|
|
|
+#endif
|
|
|
stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
|
|
|
return f != NULL;
|
|
|
}
|
|
|
@@ -245,12 +292,6 @@ static void stbi__end_write_file(stbi__write_context *s)
|
|
|
typedef unsigned int stbiw_uint32;
|
|
|
typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
|
|
|
|
|
|
-#ifdef STB_IMAGE_WRITE_STATIC
|
|
|
-static int stbi_write_tga_with_rle = 1;
|
|
|
-#else
|
|
|
-int stbi_write_tga_with_rle = 1;
|
|
|
-#endif
|
|
|
-
|
|
|
static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
|
|
|
{
|
|
|
while (*fmt) {
|
|
|
@@ -341,6 +382,9 @@ static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, i
|
|
|
if (y <= 0)
|
|
|
return;
|
|
|
|
|
|
+ if (stbi__flip_vertically_on_write)
|
|
|
+ vdir *= -1;
|
|
|
+
|
|
|
if (vdir < 0)
|
|
|
j_end = -1, j = y-1;
|
|
|
else
|
|
|
@@ -412,11 +456,21 @@ static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, v
|
|
|
"111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);
|
|
|
} else {
|
|
|
int i,j,k;
|
|
|
+ int jend, jdir;
|
|
|
|
|
|
stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8);
|
|
|
|
|
|
- for (j = y - 1; j >= 0; --j) {
|
|
|
- unsigned char *row = (unsigned char *) data + j * x * comp;
|
|
|
+ if (stbi__flip_vertically_on_write) {
|
|
|
+ j = 0;
|
|
|
+ jend = y;
|
|
|
+ jdir = 1;
|
|
|
+ } else {
|
|
|
+ j = y-1;
|
|
|
+ jend = -1;
|
|
|
+ jdir = -1;
|
|
|
+ }
|
|
|
+ for (; j != jend; j += jdir) {
|
|
|
+ unsigned char *row = (unsigned char *) data + j * x * comp;
|
|
|
int len;
|
|
|
|
|
|
for (i = 0; i < x; i += len) {
|
|
|
@@ -626,11 +680,15 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, f
|
|
|
char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
|
|
|
s->func(s->context, header, sizeof(header)-1);
|
|
|
|
|
|
+#ifdef STBI_MSC_SECURE_CRT
|
|
|
+ len = sprintf_s(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
|
|
|
+#else
|
|
|
len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
|
|
|
+#endif
|
|
|
s->func(s->context, buffer, len);
|
|
|
|
|
|
for(i=0; i < y; i++)
|
|
|
- stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*i*x);
|
|
|
+ stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)*x);
|
|
|
STBIW_FREE(scratch);
|
|
|
return 1;
|
|
|
}
|
|
|
@@ -662,6 +720,7 @@ STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const
|
|
|
// PNG writer
|
|
|
//
|
|
|
|
|
|
+#ifndef STBIW_ZLIB_COMPRESS
|
|
|
// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
|
|
|
#define stbiw__sbraw(a) ((int *) (a) - 2)
|
|
|
#define stbiw__sbm(a) stbiw__sbraw(a)[0]
|
|
|
@@ -742,8 +801,14 @@ static unsigned int stbiw__zhash(unsigned char *data)
|
|
|
|
|
|
#define stbiw__ZHASH 16384
|
|
|
|
|
|
+#endif // STBIW_ZLIB_COMPRESS
|
|
|
+
|
|
|
unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
|
|
|
{
|
|
|
+#ifdef STBIW_ZLIB_COMPRESS
|
|
|
+ // user provided a zlib compress implementation, use that
|
|
|
+ return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
|
|
|
+#else // use builtin
|
|
|
static unsigned short lengthc[] = { 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, 259 };
|
|
|
static unsigned char lengtheb[]= { 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 };
|
|
|
static unsigned short distc[] = { 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, 32768 };
|
|
|
@@ -752,6 +817,8 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|
|
int i,j, bitcount=0;
|
|
|
unsigned char *out = NULL;
|
|
|
unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(char**));
|
|
|
+ if (hash_table == NULL)
|
|
|
+ return NULL;
|
|
|
if (quality < 5) quality = 5;
|
|
|
|
|
|
stbiw__sbpush(out, 0x78); // DEFLATE 32K window
|
|
|
@@ -845,6 +912,7 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|
|
// make returned pointer freeable
|
|
|
STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
|
|
|
return (unsigned char *) stbiw__sbraw(out);
|
|
|
+#endif // STBIW_ZLIB_COMPRESS
|
|
|
}
|
|
|
|
|
|
static unsigned int stbiw__crc32(unsigned char *buffer, int len)
|
|
|
@@ -911,61 +979,87 @@ 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 int mapping[] = { 0,1,2,3,4 };
|
|
|
+ static int firstmap[] = { 0,1,0,5,6 };
|
|
|
+ int *mymap = (y != 0) ? mapping : firstmap;
|
|
|
+ int i;
|
|
|
+ int type = mymap[filter_type];
|
|
|
+ unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
|
|
|
+ for (i = 0; i < n; ++i) {
|
|
|
+ switch (type) {
|
|
|
+ case 0: line_buffer[i] = z[i]; break;
|
|
|
+ case 1: line_buffer[i] = z[i]; break;
|
|
|
+ case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
|
|
|
+ case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
|
|
|
+ case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-stride_bytes],0)); break;
|
|
|
+ case 5: line_buffer[i] = z[i]; break;
|
|
|
+ case 6: line_buffer[i] = z[i]; break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (i=n; i < width*n; ++i) {
|
|
|
+ switch (type) {
|
|
|
+ case 0: line_buffer[i] = z[i]; break;
|
|
|
+ case 1: line_buffer[i] = z[i] - z[i-n]; break;
|
|
|
+ case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
|
|
|
+ case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
|
|
|
+ case 4: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
|
|
|
+ case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
|
|
|
+ case 6: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
|
|
|
{
|
|
|
+ int force_filter = stbi_write_force_png_filter;
|
|
|
int ctype[5] = { -1, 0, 4, 2, 6 };
|
|
|
unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
|
|
|
unsigned char *out,*o, *filt, *zlib;
|
|
|
signed char *line_buffer;
|
|
|
- int i,j,k,p,zlen;
|
|
|
+ int j,zlen;
|
|
|
|
|
|
if (stride_bytes == 0)
|
|
|
stride_bytes = x * n;
|
|
|
|
|
|
+ if (force_filter >= 5) {
|
|
|
+ force_filter = -1;
|
|
|
+ }
|
|
|
+
|
|
|
filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
|
|
|
line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
|
|
|
for (j=0; j < y; ++j) {
|
|
|
- static int mapping[] = { 0,1,2,3,4 };
|
|
|
- static int firstmap[] = { 0,1,0,5,6 };
|
|
|
- int *mymap = (j != 0) ? mapping : firstmap;
|
|
|
- int best = 0, bestval = 0x7fffffff;
|
|
|
- for (p=0; p < 2; ++p) {
|
|
|
- for (k= p?best:0; k < 5; ++k) { // @TODO: clarity: rewrite this to go 0..5, and 'continue' the unwanted ones during 2nd pass
|
|
|
- int type = mymap[k],est=0;
|
|
|
- unsigned char *z = pixels + stride_bytes*j;
|
|
|
- for (i=0; i < n; ++i)
|
|
|
- switch (type) {
|
|
|
- case 0: line_buffer[i] = z[i]; break;
|
|
|
- case 1: line_buffer[i] = z[i]; break;
|
|
|
- case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
|
|
|
- case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
|
|
|
- case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-stride_bytes],0)); break;
|
|
|
- case 5: line_buffer[i] = z[i]; break;
|
|
|
- case 6: line_buffer[i] = z[i]; break;
|
|
|
- }
|
|
|
- for (i=n; i < x*n; ++i) {
|
|
|
- switch (type) {
|
|
|
- case 0: line_buffer[i] = z[i]; break;
|
|
|
- case 1: line_buffer[i] = z[i] - z[i-n]; break;
|
|
|
- case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
|
|
|
- case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
|
|
|
- case 4: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
|
|
|
- case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
|
|
|
- case 6: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (p) break;
|
|
|
- for (i=0; i < x*n; ++i)
|
|
|
+ int filter_type;
|
|
|
+ if (force_filter > -1) {
|
|
|
+ filter_type = force_filter;
|
|
|
+ stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, force_filter, line_buffer);
|
|
|
+ } else { // Estimate the best filter by running through all of them:
|
|
|
+ int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
|
|
|
+ for (filter_type = 0; filter_type < 5; filter_type++) {
|
|
|
+ stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, filter_type, line_buffer);
|
|
|
+
|
|
|
+ // Estimate the entropy of the line using this filter; the less, the better.
|
|
|
+ est = 0;
|
|
|
+ for (i = 0; i < x*n; ++i) {
|
|
|
est += abs((signed char) line_buffer[i]);
|
|
|
- if (est < bestval) { bestval = est; best = k; }
|
|
|
+ }
|
|
|
+ if (est < best_filter_val) {
|
|
|
+ best_filter_val = est;
|
|
|
+ best_filter = filter_type;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it
|
|
|
+ stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, best_filter, line_buffer);
|
|
|
+ filter_type = best_filter;
|
|
|
}
|
|
|
}
|
|
|
- // when we get here, best contains the filter type, and line_buffer contains the data
|
|
|
- filt[j*(x*n+1)] = (unsigned char) best;
|
|
|
+ // when we get here, filter_type contains the filter type, and line_buffer contains the data
|
|
|
+ filt[j*(x*n+1)] = (unsigned char) filter_type;
|
|
|
STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
|
|
|
}
|
|
|
STBIW_FREE(line_buffer);
|
|
|
- zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, 8); // increase 8 to get smaller but use more memory
|
|
|
+ zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
|
|
|
STBIW_FREE(filt);
|
|
|
if (!zlib) return 0;
|
|
|
|
|
|
@@ -1010,7 +1104,12 @@ STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const
|
|
|
int len;
|
|
|
unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
|
|
|
if (png == NULL) return 0;
|
|
|
+#ifdef STBI_MSC_SECURE_CRT
|
|
|
+ if (fopen_s(&f, filename, "wb"))
|
|
|
+ f = NULL;
|
|
|
+#else
|
|
|
f = fopen(filename, "wb");
|
|
|
+#endif
|
|
|
if (!f) { STBIW_FREE(png); return 0; }
|
|
|
fwrite(png, 1, len, f);
|
|
|
fclose(f);
|
|
|
@@ -1318,7 +1417,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|
|
float YDU[64], UDU[64], VDU[64];
|
|
|
for(row = y, pos = 0; row < y+8; ++row) {
|
|
|
for(col = x; col < x+8; ++col, ++pos) {
|
|
|
- int p = row*width*comp + col*comp;
|
|
|
+ int p = (stbi__flip_vertically_on_write ? height-1-row : row)*width*comp + col*comp;
|
|
|
float r, g, b;
|
|
|
if(row >= height) {
|
|
|
p -= width*comp*(row+1 - height);
|
|
|
@@ -1377,6 +1476,8 @@ STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const
|
|
|
#endif // STB_IMAGE_WRITE_IMPLEMENTATION
|
|
|
|
|
|
/* Revision history
|
|
|
+ 1.08 (2018-01-29)
|
|
|
+ add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
|
|
|
1.07 (2017-07-24)
|
|
|
doc fix
|
|
|
1.06 (2017-07-23)
|
Ray