AtlatestRepositorysigil-image
sigil-image / tree / vendor / stbstb_image_write.h
1
/* stb_image_write - v1.16 - public domain - http://nothings.org/stb2
writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-20153
no warranty implied; use at your own risk5
Before #including,7
#define STB_IMAGE_WRITE_IMPLEMENTATION9
in the file that you want to have the implementation.11
Will probably not work correctly with strict-aliasing optimizations.13
ABOUT:15
This header file is a library for writing images to C stdio or a callback.17
The PNG output is not optimal; it is 20-50% larger than the file18
written by a decent optimizing implementation; though providing a custom19
zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that.20
This library is designed for source code compactness and simplicity,21
not optimal image file size or run-time performance.23
BUILDING:25
You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h.26
You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace27
malloc,realloc,free.28
You can #define STBIW_MEMMOVE() to replace memmove()29
You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function30
for PNG compression (instead of the builtin one), it must have the following signature:31
unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality);32
The returned data will be freed with STBIW_FREE() (free() by default),33
so it must be heap allocated with STBIW_MALLOC() (malloc() by default),35
UNICODE:37
If compiling for Windows and you wish to use Unicode filenames, compile38
with39
#define STBIW_WINDOWS_UTF840
and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert41
Windows wchar_t filenames to utf8.43
USAGE:45
There are five functions, one for each image file format:47
int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);48
int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);49
int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);50
int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality);51
int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);53
void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically55
There are also five equivalent functions that use an arbitrary write function. You are56
expected to open/close your file-equivalent before and after calling these:58
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);59
int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);60
int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);61
int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);62
int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);64
where the callback is:65
void stbi_write_func(void *context, void *data, int size);67
You can configure it with these global variables:68
int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE69
int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression70
int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode73
You can define STBI_WRITE_NO_STDIO to disable the file variant of these74
functions, so the library will not use stdio.h at all. However, this will75
also disable HDR writing, because it requires stdio for formatted output.77
Each function returns 0 on failure and non-0 on success.79
The functions create an image file defined by the parameters. The image80
is a rectangle of pixels stored from left-to-right, top-to-bottom.81
Each pixel contains 'comp' channels of data stored interleaved with 8-bits82
per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is83
monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.84
The *data pointer points to the first byte of the top-left-most pixel.85
For PNG, "stride_in_bytes" is the distance in bytes from the first byte of86
a row of pixels to the first byte of the next row of pixels.88
PNG creates output files with the same number of components as the input.89
The BMP format expands Y to RGB in the file format and does not90
output alpha.92
PNG supports writing rectangles of data even when the bytes storing rows of93
data are not consecutive in memory (e.g. sub-rectangles of a larger image),94
by supplying the stride between the beginning of adjacent rows. The other95
formats do not. (Thus you cannot write a native-format BMP through the BMP96
writer, both because it is in BGR order and because it may have padding97
at the end of the line.)99
PNG allows you to set the deflate compression level by setting the global100
variable 'stbi_write_png_compression_level' (it defaults to 8).102
HDR expects linear float data. Since the format is always 32-bit rgb(e)103
data, alpha (if provided) is discarded, and for monochrome data it is104
replicated across all three channels.106
TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed107
data, set the global variable 'stbi_write_tga_with_rle' to 0.109
JPEG does ignore alpha channels in input data; quality is between 1 and 100.110
Higher quality looks better but results in a bigger image.111
JPEG baseline (no JPEG progressive).113
CREDITS:116
Sean Barrett - PNG/BMP/TGA117
Baldur Karlsson - HDR118
Jean-Sebastien Guay - TGA monochrome119
Tim Kelsey - misc enhancements120
Alan Hickman - TGA RLE121
Emmanuel Julien - initial file IO callback implementation122
Jon Olick - original jo_jpeg.cpp code123
Daniel Gibson - integrate JPEG, allow external zlib124
Aarni Koskela - allow choosing PNG filter126
bugfixes:127
github:Chribba128
Guillaume Chereau129
github:jry2130
github:romigrou131
Sergio Gonzalez132
Jonas Karlsson133
Filip Wasil134
Thatcher Ulrich135
github:poppolopoppo136
Patrick Boettcher137
github:xeekworx138
Cap Petschulat139
Simon Rodriguez140
Ivan Tikhonov141
github:ignotion142
Adam Schackart143
Andrew Kensler145
LICENSE147
See end of file for license information.149
*/151
#ifndef INCLUDE_STB_IMAGE_WRITE_H152
#define INCLUDE_STB_IMAGE_WRITE_H154
#include <stdlib.h>156
// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'157
#ifndef STBIWDEF158
#ifdef STB_IMAGE_WRITE_STATIC159
#define STBIWDEF static160
#else161
#ifdef __cplusplus162
#define STBIWDEF extern "C"163
#else164
#define STBIWDEF extern165
#endif166
#endif167
#endif169
#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations170
STBIWDEF int stbi_write_tga_with_rle;171
STBIWDEF int stbi_write_png_compression_level;172
STBIWDEF int stbi_write_force_png_filter;173
#endif175
#ifndef STBI_WRITE_NO_STDIO176
STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);177
STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);178
STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);179
STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);180
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);182
#ifdef STBIW_WINDOWS_UTF8183
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);184
#endif185
#endif187
typedef void stbi_write_func(void *context, void *data, int size);189
STBIWDEF 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);190
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);191
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);192
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);193
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);195
STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);197
#endif//INCLUDE_STB_IMAGE_WRITE_H199
#ifdef STB_IMAGE_WRITE_IMPLEMENTATION201
#ifdef _WIN32202
#ifndef _CRT_SECURE_NO_WARNINGS203
#define _CRT_SECURE_NO_WARNINGS204
#endif205
#ifndef _CRT_NONSTDC_NO_DEPRECATE206
#define _CRT_NONSTDC_NO_DEPRECATE207
#endif208
#endif210
#ifndef STBI_WRITE_NO_STDIO211
#include <stdio.h>212
#endif // STBI_WRITE_NO_STDIO214
#include <stdarg.h>215
#include <stdlib.h>216
#include <string.h>217
#include <math.h>219
#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))220
// ok221
#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)222
// ok223
#else224
#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."225
#endif227
#ifndef STBIW_MALLOC228
#define STBIW_MALLOC(sz) malloc(sz)229
#define STBIW_REALLOC(p,newsz) realloc(p,newsz)230
#define STBIW_FREE(p) free(p)231
#endif233
#ifndef STBIW_REALLOC_SIZED234
#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)235
#endif238
#ifndef STBIW_MEMMOVE239
#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)240
#endif243
#ifndef STBIW_ASSERT244
#include <assert.h>245
#define STBIW_ASSERT(x) assert(x)246
#endif248
#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)250
#ifdef STB_IMAGE_WRITE_STATIC251
static int stbi_write_png_compression_level = 8;252
static int stbi_write_tga_with_rle = 1;253
static int stbi_write_force_png_filter = -1;254
#else255
int stbi_write_png_compression_level = 8;256
int stbi_write_tga_with_rle = 1;257
int stbi_write_force_png_filter = -1;258
#endif260
static int stbi__flip_vertically_on_write = 0;262
STBIWDEF void stbi_flip_vertically_on_write(int flag)263
{264
stbi__flip_vertically_on_write = flag;265
}267
typedef struct268
{269
stbi_write_func *func;270
void *context;271
unsigned char buffer[64];272
int buf_used;273
} stbi__write_context;275
// initialize a callback-based context276
static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context)277
{278
s->func = c;279
s->context = context;280
}282
#ifndef STBI_WRITE_NO_STDIO284
static void stbi__stdio_write(void *context, void *data, int size)285
{286
fwrite(data,1,size,(FILE*) context);287
}289
#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)290
#ifdef __cplusplus291
#define STBIW_EXTERN extern "C"292
#else293
#define STBIW_EXTERN extern294
#endif295
STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);296
STBIW_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);298
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)299
{300
return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);301
}302
#endif304
static FILE *stbiw__fopen(char const *filename, char const *mode)305
{306
FILE *f;307
#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)308
wchar_t wMode[64];309
wchar_t wFilename[1024];310
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))311
return 0;313
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))314
return 0;316
#if defined(_MSC_VER) && _MSC_VER >= 1400317
if (0 != _wfopen_s(&f, wFilename, wMode))318
f = 0;319
#else320
f = _wfopen(wFilename, wMode);321
#endif323
#elif defined(_MSC_VER) && _MSC_VER >= 1400324
if (0 != fopen_s(&f, filename, mode))325
f=0;326
#else327
f = fopen(filename, mode);328
#endif329
return f;330
}332
static int stbi__start_write_file(stbi__write_context *s, const char *filename)333
{334
FILE *f = stbiw__fopen(filename, "wb");335
stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);336
return f != NULL;337
}339
static void stbi__end_write_file(stbi__write_context *s)340
{341
fclose((FILE *)s->context);342
}344
#endif // !STBI_WRITE_NO_STDIO346
typedef unsigned int stbiw_uint32;347
typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];349
static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)350
{351
while (*fmt) {352
switch (*fmt++) {353
case ' ': break;354
case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));355
s->func(s->context,&x,1);356
break; }357
case '2': { int x = va_arg(v,int);358
unsigned char b[2];359
b[0] = STBIW_UCHAR(x);360
b[1] = STBIW_UCHAR(x>>8);361
s->func(s->context,b,2);362
break; }363
case '4': { stbiw_uint32 x = va_arg(v,int);364
unsigned char b[4];365
b[0]=STBIW_UCHAR(x);366
b[1]=STBIW_UCHAR(x>>8);367
b[2]=STBIW_UCHAR(x>>16);368
b[3]=STBIW_UCHAR(x>>24);369
s->func(s->context,b,4);370
break; }371
default:372
STBIW_ASSERT(0);373
return;374
}375
}376
}378
static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)379
{380
va_list v;381
va_start(v, fmt);382
stbiw__writefv(s, fmt, v);383
va_end(v);384
}386
static void stbiw__write_flush(stbi__write_context *s)387
{388
if (s->buf_used) {389
s->func(s->context, &s->buffer, s->buf_used);390
s->buf_used = 0;391
}392
}394
static void stbiw__putc(stbi__write_context *s, unsigned char c)395
{396
s->func(s->context, &c, 1);397
}399
static void stbiw__write1(stbi__write_context *s, unsigned char a)400
{401
if ((size_t)s->buf_used + 1 > sizeof(s->buffer))402
stbiw__write_flush(s);403
s->buffer[s->buf_used++] = a;404
}406
static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)407
{408
int n;409
if ((size_t)s->buf_used + 3 > sizeof(s->buffer))410
stbiw__write_flush(s);411
n = s->buf_used;412
s->buf_used = n+3;413
s->buffer[n+0] = a;414
s->buffer[n+1] = b;415
s->buffer[n+2] = c;416
}418
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)419
{420
unsigned char bg[3] = { 255, 0, 255}, px[3];421
int k;423
if (write_alpha < 0)424
stbiw__write1(s, d[comp - 1]);426
switch (comp) {427
case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case428
case 1:429
if (expand_mono)430
stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp431
else432
stbiw__write1(s, d[0]); // monochrome TGA433
break;434
case 4:435
if (!write_alpha) {436
// composite against pink background437
for (k = 0; k < 3; ++k)438
px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;439
stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);440
break;441
}442
/* FALLTHROUGH */443
case 3:444
stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);445
break;446
}447
if (write_alpha > 0)448
stbiw__write1(s, d[comp - 1]);449
}451
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)452
{453
stbiw_uint32 zero = 0;454
int i,j, j_end;456
if (y <= 0)457
return;459
if (stbi__flip_vertically_on_write)460
vdir *= -1;462
if (vdir < 0) {463
j_end = -1; j = y-1;464
} else {465
j_end = y; j = 0;466
}468
for (; j != j_end; j += vdir) {469
for (i=0; i < x; ++i) {470
unsigned char *d = (unsigned char *) data + (j*x+i)*comp;471
stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);472
}473
stbiw__write_flush(s);474
s->func(s->context, &zero, scanline_pad);475
}476
}478
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, ...)479
{480
if (y < 0 || x < 0) {481
return 0;482
} else {483
va_list v;484
va_start(v, fmt);485
stbiw__writefv(s, fmt, v);486
va_end(v);487
stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);488
return 1;489
}490
}492
static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)493
{494
if (comp != 4) {495
// write RGB bitmap496
int pad = (-x*3) & 3;497
return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,498
"11 4 22 4" "4 44 22 444444",499
'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header500
40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header501
} else {502
// RGBA bitmaps need a v4 header503
// use BI_BITFIELDS mode with 32bpp and alpha mask504
// (straight BI_RGB with alpha mask doesn't work in most readers)505
return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0,506
"11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444",507
'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header508
108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header509
}510
}512
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)513
{514
stbi__write_context s = { 0 };515
stbi__start_write_callbacks(&s, func, context);516
return stbi_write_bmp_core(&s, x, y, comp, data);517
}519
#ifndef STBI_WRITE_NO_STDIO520
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)521
{522
stbi__write_context s = { 0 };523
if (stbi__start_write_file(&s,filename)) {524
int r = stbi_write_bmp_core(&s, x, y, comp, data);525
stbi__end_write_file(&s);526
return r;527
} else528
return 0;529
}530
#endif //!STBI_WRITE_NO_STDIO532
static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data)533
{534
int has_alpha = (comp == 2 || comp == 4);535
int colorbytes = has_alpha ? comp-1 : comp;536
int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3538
if (y < 0 || x < 0)539
return 0;541
if (!stbi_write_tga_with_rle) {542
return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0,543
"111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8);544
} else {545
int i,j,k;546
int jend, jdir;548
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);550
if (stbi__flip_vertically_on_write) {551
j = 0;552
jend = y;553
jdir = 1;554
} else {555
j = y-1;556
jend = -1;557
jdir = -1;558
}559
for (; j != jend; j += jdir) {560
unsigned char *row = (unsigned char *) data + j * x * comp;561
int len;563
for (i = 0; i < x; i += len) {564
unsigned char *begin = row + i * comp;565
int diff = 1;566
len = 1;568
if (i < x - 1) {569
++len;570
diff = memcmp(begin, row + (i + 1) * comp, comp);571
if (diff) {572
const unsigned char *prev = begin;573
for (k = i + 2; k < x && len < 128; ++k) {574
if (memcmp(prev, row + k * comp, comp)) {575
prev += comp;576
++len;577
} else {578
--len;579
break;580
}581
}582
} else {583
for (k = i + 2; k < x && len < 128; ++k) {584
if (!memcmp(begin, row + k * comp, comp)) {585
++len;586
} else {587
break;588
}589
}590
}591
}593
if (diff) {594
unsigned char header = STBIW_UCHAR(len - 1);595
stbiw__write1(s, header);596
for (k = 0; k < len; ++k) {597
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);598
}599
} else {600
unsigned char header = STBIW_UCHAR(len - 129);601
stbiw__write1(s, header);602
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);603
}604
}605
}606
stbiw__write_flush(s);607
}608
return 1;609
}611
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)612
{613
stbi__write_context s = { 0 };614
stbi__start_write_callbacks(&s, func, context);615
return stbi_write_tga_core(&s, x, y, comp, (void *) data);616
}618
#ifndef STBI_WRITE_NO_STDIO619
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)620
{621
stbi__write_context s = { 0 };622
if (stbi__start_write_file(&s,filename)) {623
int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);624
stbi__end_write_file(&s);625
return r;626
} else627
return 0;628
}629
#endif631
// *************************************************************************************************632
// Radiance RGBE HDR writer633
// by Baldur Karlsson635
#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))637
#ifndef STBI_WRITE_NO_STDIO639
static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)640
{641
int exponent;642
float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));644
if (maxcomp < 1e-32f) {645
rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;646
} else {647
float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;649
rgbe[0] = (unsigned char)(linear[0] * normalize);650
rgbe[1] = (unsigned char)(linear[1] * normalize);651
rgbe[2] = (unsigned char)(linear[2] * normalize);652
rgbe[3] = (unsigned char)(exponent + 128);653
}654
}656
static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)657
{658
unsigned char lengthbyte = STBIW_UCHAR(length+128);659
STBIW_ASSERT(length+128 <= 255);660
s->func(s->context, &lengthbyte, 1);661
s->func(s->context, &databyte, 1);662
}664
static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)665
{666
unsigned char lengthbyte = STBIW_UCHAR(length);667
STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code668
s->func(s->context, &lengthbyte, 1);669
s->func(s->context, data, length);670
}672
static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)673
{674
unsigned char scanlineheader[4] = { 2, 2, 0, 0 };675
unsigned char rgbe[4];676
float linear[3];677
int x;679
scanlineheader[2] = (width&0xff00)>>8;680
scanlineheader[3] = (width&0x00ff);682
/* skip RLE for images too small or large */683
if (width < 8 || width >= 32768) {684
for (x=0; x < width; x++) {685
switch (ncomp) {686
case 4: /* fallthrough */687
case 3: linear[2] = scanline[x*ncomp + 2];688
linear[1] = scanline[x*ncomp + 1];689
linear[0] = scanline[x*ncomp + 0];690
break;691
default:692
linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];693
break;694
}695
stbiw__linear_to_rgbe(rgbe, linear);696
s->func(s->context, rgbe, 4);697
}698
} else {699
int c,r;700
/* encode into scratch buffer */701
for (x=0; x < width; x++) {702
switch(ncomp) {703
case 4: /* fallthrough */704
case 3: linear[2] = scanline[x*ncomp + 2];705
linear[1] = scanline[x*ncomp + 1];706
linear[0] = scanline[x*ncomp + 0];707
break;708
default:709
linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];710
break;711
}712
stbiw__linear_to_rgbe(rgbe, linear);713
scratch[x + width*0] = rgbe[0];714
scratch[x + width*1] = rgbe[1];715
scratch[x + width*2] = rgbe[2];716
scratch[x + width*3] = rgbe[3];717
}719
s->func(s->context, scanlineheader, 4);721
/* RLE each component separately */722
for (c=0; c < 4; c++) {723
unsigned char *comp = &scratch[width*c];725
x = 0;726
while (x < width) {727
// find first run728
r = x;729
while (r+2 < width) {730
if (comp[r] == comp[r+1] && comp[r] == comp[r+2])731
break;732
++r;733
}734
if (r+2 >= width)735
r = width;736
// dump up to first run737
while (x < r) {738
int len = r-x;739
if (len > 128) len = 128;740
stbiw__write_dump_data(s, len, &comp[x]);741
x += len;742
}743
// if there's a run, output it744
if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd745
// find next byte after run746
while (r < width && comp[r] == comp[x])747
++r;748
// output run up to r749
while (x < r) {750
int len = r-x;751
if (len > 127) len = 127;752
stbiw__write_run_data(s, len, comp[x]);753
x += len;754
}755
}756
}757
}758
}759
}761
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)762
{763
if (y <= 0 || x <= 0 || data == NULL)764
return 0;765
else {766
// Each component is stored separately. Allocate scratch space for full output scanline.767
unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);768
int i, len;769
char buffer[128];770
char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";771
s->func(s->context, header, sizeof(header)-1);773
#ifdef __STDC_LIB_EXT1__774
len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);775
#else776
len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);777
#endif778
s->func(s->context, buffer, len);780
for(i=0; i < y; i++)781
stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));782
STBIW_FREE(scratch);783
return 1;784
}785
}787
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)788
{789
stbi__write_context s = { 0 };790
stbi__start_write_callbacks(&s, func, context);791
return stbi_write_hdr_core(&s, x, y, comp, (float *) data);792
}794
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)795
{796
stbi__write_context s = { 0 };797
if (stbi__start_write_file(&s,filename)) {798
int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);799
stbi__end_write_file(&s);800
return r;801
} else802
return 0;803
}804
#endif // STBI_WRITE_NO_STDIO807
//////////////////////////////////////////////////////////////////////////////808
//809
// PNG writer810
//812
#ifndef STBIW_ZLIB_COMPRESS813
// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()814
#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)815
#define stbiw__sbm(a) stbiw__sbraw(a)[0]816
#define stbiw__sbn(a) stbiw__sbraw(a)[1]818
#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))819
#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)820
#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))822
#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))823
#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)824
#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)826
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)827
{828
int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;829
void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);830
STBIW_ASSERT(p);831
if (p) {832
if (!*arr) ((int *) p)[1] = 0;833
*arr = (void *) ((int *) p + 2);834
stbiw__sbm(*arr) = m;835
}836
return *arr;837
}839
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)840
{841
while (*bitcount >= 8) {842
stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));843
*bitbuffer >>= 8;844
*bitcount -= 8;845
}846
return data;847
}849
static int stbiw__zlib_bitrev(int code, int codebits)850
{851
int res=0;852
while (codebits--) {853
res = (res << 1) | (code & 1);854
code >>= 1;855
}856
return res;857
}859
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)860
{861
int i;862
for (i=0; i < limit && i < 258; ++i)863
if (a[i] != b[i]) break;864
return i;865
}867
static unsigned int stbiw__zhash(unsigned char *data)868
{869
stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);870
hash ^= hash << 3;871
hash += hash >> 5;872
hash ^= hash << 4;873
hash += hash >> 17;874
hash ^= hash << 25;875
hash += hash >> 6;876
return hash;877
}879
#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))880
#define stbiw__zlib_add(code,codebits) \881
(bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())882
#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)883
// default huffman tables884
#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)885
#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)886
#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)887
#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)888
#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n))889
#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))891
#define stbiw__ZHASH 16384893
#endif // STBIW_ZLIB_COMPRESS895
STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)896
{897
#ifdef STBIW_ZLIB_COMPRESS898
// user provided a zlib compress implementation, use that899
return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);900
#else // use builtin901
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 };902
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 };903
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 };904
static unsigned char disteb[] = { 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 };905
unsigned int bitbuf=0;906
int i,j, bitcount=0;907
unsigned char *out = NULL;908
unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));909
if (hash_table == NULL)910
return NULL;911
if (quality < 5) quality = 5;913
stbiw__sbpush(out, 0x78); // DEFLATE 32K window914
stbiw__sbpush(out, 0x5e); // FLEVEL = 1915
stbiw__zlib_add(1,1); // BFINAL = 1916
stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman918
for (i=0; i < stbiw__ZHASH; ++i)919
hash_table[i] = NULL;921
i=0;922
while (i < data_len-3) {923
// hash next 3 bytes of data to be compressed924
int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;925
unsigned char *bestloc = 0;926
unsigned char **hlist = hash_table[h];927
int n = stbiw__sbcount(hlist);928
for (j=0; j < n; ++j) {929
if (hlist[j]-data > i-32768) { // if entry lies within window930
int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);931
if (d >= best) { best=d; bestloc=hlist[j]; }932
}933
}934
// when hash table entry is too long, delete half the entries935
if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {936
STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);937
stbiw__sbn(hash_table[h]) = quality;938
}939
stbiw__sbpush(hash_table[h],data+i);941
if (bestloc) {942
// "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal943
h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);944
hlist = hash_table[h];945
n = stbiw__sbcount(hlist);946
for (j=0; j < n; ++j) {947
if (hlist[j]-data > i-32767) {948
int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);949
if (e > best) { // if next match is better, bail on current match950
bestloc = NULL;951
break;952
}953
}954
}955
}957
if (bestloc) {958
int d = (int) (data+i - bestloc); // distance back959
STBIW_ASSERT(d <= 32767 && best <= 258);960
for (j=0; best > lengthc[j+1]-1; ++j);961
stbiw__zlib_huff(j+257);962
if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);963
for (j=0; d > distc[j+1]-1; ++j);964
stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);965
if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);966
i += best;967
} else {968
stbiw__zlib_huffb(data[i]);969
++i;970
}971
}972
// write out final bytes973
for (;i < data_len; ++i)974
stbiw__zlib_huffb(data[i]);975
stbiw__zlib_huff(256); // end of block976
// pad with 0 bits to byte boundary977
while (bitcount)978
stbiw__zlib_add(0,1);980
for (i=0; i < stbiw__ZHASH; ++i)981
(void) stbiw__sbfree(hash_table[i]);982
STBIW_FREE(hash_table);984
// store uncompressed instead if compression was worse985
if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {986
stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1987
for (j = 0; j < data_len;) {988
int blocklen = data_len - j;989
if (blocklen > 32767) blocklen = 32767;990
stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression991
stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN992
stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));993
stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN994
stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));995
memcpy(out+stbiw__sbn(out), data+j, blocklen);996
stbiw__sbn(out) += blocklen;997
j += blocklen;998
}999
}1001
{1002
// compute adler32 on input1003
unsigned int s1=1, s2=0;1004
int blocklen = (int) (data_len % 5552);1005
j=0;1006
while (j < data_len) {1007
for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }1008
s1 %= 65521; s2 %= 65521;1009
j += blocklen;1010
blocklen = 5552;1011
}1012
stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));1013
stbiw__sbpush(out, STBIW_UCHAR(s2));1014
stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));1015
stbiw__sbpush(out, STBIW_UCHAR(s1));1016
}1017
*out_len = stbiw__sbn(out);1018
// make returned pointer freeable1019
STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);1020
return (unsigned char *) stbiw__sbraw(out);1021
#endif // STBIW_ZLIB_COMPRESS1022
}1024
static unsigned int stbiw__crc32(unsigned char *buffer, int len)1025
{1026
#ifdef STBIW_CRC321027
return STBIW_CRC32(buffer, len);1028
#else1029
static unsigned int crc_table[256] =1030
{1031
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,1032
0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,1033
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,1034
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,1035
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,1036
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,1037
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,1038
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,1039
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,1040
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,1041
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,1042
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,1043
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,1044
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,1045
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,1046
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,1047
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,1048
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,1049
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,1050
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,1051
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,1052
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,1053
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,1054
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,1055
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,1056
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,1057
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,1058
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,1059
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,1060
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,1061
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,1062
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D1063
};1065
unsigned int crc = ~0u;1066
int i;1067
for (i=0; i < len; ++i)1068
crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];1069
return ~crc;1070
#endif1071
}1073
#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)1074
#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));1075
#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])1077
static void stbiw__wpcrc(unsigned char **data, int len)1078
{1079
unsigned int crc = stbiw__crc32(*data - len - 4, len+4);1080
stbiw__wp32(*data, crc);1081
}1083
static unsigned char stbiw__paeth(int a, int b, int c)1084
{1085
int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);1086
if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);1087
if (pb <= pc) return STBIW_UCHAR(b);1088
return STBIW_UCHAR(c);1089
}1091
// @OPTIMIZE: provide an option that always forces left-predict or paeth predict1092
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)1093
{1094
static int mapping[] = { 0,1,2,3,4 };1095
static int firstmap[] = { 0,1,0,5,6 };1096
int *mymap = (y != 0) ? mapping : firstmap;1097
int i;1098
int type = mymap[filter_type];1099
unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);1100
int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;1102
if (type==0) {1103
memcpy(line_buffer, z, width*n);1104
return;1105
}1107
// first loop isn't optimized since it's just one pixel1108
for (i = 0; i < n; ++i) {1109
switch (type) {1110
case 1: line_buffer[i] = z[i]; break;1111
case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;1112
case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;1113
case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;1114
case 5: line_buffer[i] = z[i]; break;1115
case 6: line_buffer[i] = z[i]; break;1116
}1117
}1118
switch (type) {1119
case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;1120
case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;1121
case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;1122
case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;1123
case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;1124
case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;1125
}1126
}1128
STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)1129
{1130
int force_filter = stbi_write_force_png_filter;1131
int ctype[5] = { -1, 0, 4, 2, 6 };1132
unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };1133
unsigned char *out,*o, *filt, *zlib;1134
signed char *line_buffer;1135
int j,zlen;1137
if (stride_bytes == 0)1138
stride_bytes = x * n;1140
if (force_filter >= 5) {1141
force_filter = -1;1142
}1144
filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;1145
line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }1146
for (j=0; j < y; ++j) {1147
int filter_type;1148
if (force_filter > -1) {1149
filter_type = force_filter;1150
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);1151
} else { // Estimate the best filter by running through all of them:1152
int best_filter = 0, best_filter_val = 0x7fffffff, est, i;1153
for (filter_type = 0; filter_type < 5; filter_type++) {1154
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);1156
// Estimate the entropy of the line using this filter; the less, the better.1157
est = 0;1158
for (i = 0; i < x*n; ++i) {1159
est += abs((signed char) line_buffer[i]);1160
}1161
if (est < best_filter_val) {1162
best_filter_val = est;1163
best_filter = filter_type;1164
}1165
}1166
if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it1167
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);1168
filter_type = best_filter;1169
}1170
}1171
// when we get here, filter_type contains the filter type, and line_buffer contains the data1172
filt[j*(x*n+1)] = (unsigned char) filter_type;1173
STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);1174
}1175
STBIW_FREE(line_buffer);1176
zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);1177
STBIW_FREE(filt);1178
if (!zlib) return 0;1180
// each tag requires 12 bytes of overhead1181
out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);1182
if (!out) return 0;1183
*out_len = 8 + 12+13 + 12+zlen + 12;1185
o=out;1186
STBIW_MEMMOVE(o,sig,8); o+= 8;1187
stbiw__wp32(o, 13); // header length1188
stbiw__wptag(o, "IHDR");1189
stbiw__wp32(o, x);1190
stbiw__wp32(o, y);1191
*o++ = 8;1192
*o++ = STBIW_UCHAR(ctype[n]);1193
*o++ = 0;1194
*o++ = 0;1195
*o++ = 0;1196
stbiw__wpcrc(&o,13);1198
stbiw__wp32(o, zlen);1199
stbiw__wptag(o, "IDAT");1200
STBIW_MEMMOVE(o, zlib, zlen);1201
o += zlen;1202
STBIW_FREE(zlib);1203
stbiw__wpcrc(&o, zlen);1205
stbiw__wp32(o,0);1206
stbiw__wptag(o, "IEND");1207
stbiw__wpcrc(&o,0);1209
STBIW_ASSERT(o == out + *out_len);1211
return out;1212
}1214
#ifndef STBI_WRITE_NO_STDIO1215
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)1216
{1217
FILE *f;1218
int len;1219
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);1220
if (png == NULL) return 0;1222
f = stbiw__fopen(filename, "wb");1223
if (!f) { STBIW_FREE(png); return 0; }1224
fwrite(png, 1, len, f);1225
fclose(f);1226
STBIW_FREE(png);1227
return 1;1228
}1229
#endif1231
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)1232
{1233
int len;1234
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);1235
if (png == NULL) return 0;1236
func(context, png, len);1237
STBIW_FREE(png);1238
return 1;1239
}1242
/* ***************************************************************************1243
*1244
* JPEG writer1245
*1246
* This is based on Jon Olick's jo_jpeg.cpp:1247
* public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html1248
*/1250
static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,1251
24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 };1253
static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {1254
int bitBuf = *bitBufP, bitCnt = *bitCntP;1255
bitCnt += bs[1];1256
bitBuf |= bs[0] << (24 - bitCnt);1257
while(bitCnt >= 8) {1258
unsigned char c = (bitBuf >> 16) & 255;1259
stbiw__putc(s, c);1260
if(c == 255) {1261
stbiw__putc(s, 0);1262
}1263
bitBuf <<= 8;1264
bitCnt -= 8;1265
}1266
*bitBufP = bitBuf;1267
*bitCntP = bitCnt;1268
}1270
static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {1271
float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;1272
float z1, z2, z3, z4, z5, z11, z13;1274
float tmp0 = d0 + d7;1275
float tmp7 = d0 - d7;1276
float tmp1 = d1 + d6;1277
float tmp6 = d1 - d6;1278
float tmp2 = d2 + d5;1279
float tmp5 = d2 - d5;1280
float tmp3 = d3 + d4;1281
float tmp4 = d3 - d4;1283
// Even part1284
float tmp10 = tmp0 + tmp3; // phase 21285
float tmp13 = tmp0 - tmp3;1286
float tmp11 = tmp1 + tmp2;1287
float tmp12 = tmp1 - tmp2;1289
d0 = tmp10 + tmp11; // phase 31290
d4 = tmp10 - tmp11;1292
z1 = (tmp12 + tmp13) * 0.707106781f; // c41293
d2 = tmp13 + z1; // phase 51294
d6 = tmp13 - z1;1296
// Odd part1297
tmp10 = tmp4 + tmp5; // phase 21298
tmp11 = tmp5 + tmp6;1299
tmp12 = tmp6 + tmp7;1301
// The rotator is modified from fig 4-8 to avoid extra negations.1302
z5 = (tmp10 - tmp12) * 0.382683433f; // c61303
z2 = tmp10 * 0.541196100f + z5; // c2-c61304
z4 = tmp12 * 1.306562965f + z5; // c2+c61305
z3 = tmp11 * 0.707106781f; // c41307
z11 = tmp7 + z3; // phase 51308
z13 = tmp7 - z3;1310
*d5p = z13 + z2; // phase 61311
*d3p = z13 - z2;1312
*d1p = z11 + z4;1313
*d7p = z11 - z4;1315
*d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6;1316
}1318
static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {1319
int tmp1 = val < 0 ? -val : val;1320
val = val < 0 ? val-1 : val;1321
bits[1] = 1;1322
while(tmp1 >>= 1) {1323
++bits[1];1324
}1325
bits[0] = val & ((1<<bits[1])-1);1326
}1328
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]) {1329
const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };1330
const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };1331
int dataOff, i, j, n, diff, end0pos, x, y;1332
int DU[64];1334
// DCT rows1335
for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {1336
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);1337
}1338
// DCT columns1339
for(dataOff=0; dataOff<8; ++dataOff) {1340
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],1341
&CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);1342
}1343
// Quantize/descale/zigzag the coefficients1344
for(y = 0, j=0; y < 8; ++y) {1345
for(x = 0; x < 8; ++x,++j) {1346
float v;1347
i = y*du_stride+x;1348
v = CDU[i]*fdtbl[j];1349
// DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));1350
// ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?1351
DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);1352
}1353
}1355
// Encode DC1356
diff = DU[0] - DC;1357
if (diff == 0) {1358
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);1359
} else {1360
unsigned short bits[2];1361
stbiw__jpg_calcBits(diff, bits);1362
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);1363
stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);1364
}1365
// Encode ACs1366
end0pos = 63;1367
for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {1368
}1369
// end0pos = first element in reverse order !=01370
if(end0pos == 0) {1371
stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);1372
return DU[0];1373
}1374
for(i = 1; i <= end0pos; ++i) {1375
int startpos = i;1376
int nrzeroes;1377
unsigned short bits[2];1378
for (; DU[i]==0 && i<=end0pos; ++i) {1379
}1380
nrzeroes = i-startpos;1381
if ( nrzeroes >= 16 ) {1382
int lng = nrzeroes>>4;1383
int nrmarker;1384
for (nrmarker=1; nrmarker <= lng; ++nrmarker)1385
stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);1386
nrzeroes &= 15;1387
}1388
stbiw__jpg_calcBits(DU[i], bits);1389
stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);1390
stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);1391
}1392
if(end0pos != 63) {1393
stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);1394
}1395
return DU[0];1396
}1398
static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {1399
// Constants that don't pollute global namespace1400
static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};1401
static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};1402
static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};1403
static const unsigned char std_ac_luminance_values[] = {1404
0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,1405
0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,1406
0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,1407
0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,1408
0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,1409
0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,1410
0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa1411
};1412
static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};1413
static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};1414
static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};1415
static const unsigned char std_ac_chrominance_values[] = {1416
0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,1417
0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,1418
0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,1419
0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,1420
0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,1421
0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,1422
0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa1423
};1424
// Huffman tables1425
static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}};1426
static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}};1427
static const unsigned short YAC_HT[256][2] = {1428
{10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1429
{12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1430
{28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1431
{58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1432
{59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1433
{122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1434
{123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1435
{250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1436
{504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1437
{505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1438
{506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1439
{1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1440
{1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1441
{2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1442
{65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0},1443
{2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}1444
};1445
static const unsigned short UVAC_HT[256][2] = {1446
{0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1447
{11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1448
{26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1449
{27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1450
{58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1451
{59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1452
{121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1453
{122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1454
{249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1455
{503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1456
{504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1457
{505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1458
{506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1459
{2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},1460
{16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0},1461
{1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0}1462
};1463
static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,1464
37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};1465
static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,1466
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};1467
static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,1468
1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };1470
int row, col, i, k, subsample;1471
float fdtbl_Y[64], fdtbl_UV[64];1472
unsigned char YTable[64], UVTable[64];1474
if(!data || !width || !height || comp > 4 || comp < 1) {1475
return 0;1476
}1478
quality = quality ? quality : 90;1479
subsample = quality <= 90 ? 1 : 0;1480
quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;1481
quality = quality < 50 ? 5000 / quality : 200 - quality * 2;1483
for(i = 0; i < 64; ++i) {1484
int uvti, yti = (YQT[i]*quality+50)/100;1485
YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);1486
uvti = (UVQT[i]*quality+50)/100;1487
UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);1488
}1490
for(row = 0, k = 0; row < 8; ++row) {1491
for(col = 0; col < 8; ++col, ++k) {1492
fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);1493
fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);1494
}1495
}1497
// Write Headers1498
{1499
static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };1500
static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };1501
const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),1502
3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };1503
s->func(s->context, (void*)head0, sizeof(head0));1504
s->func(s->context, (void*)YTable, sizeof(YTable));1505
stbiw__putc(s, 1);1506
s->func(s->context, UVTable, sizeof(UVTable));1507
s->func(s->context, (void*)head1, sizeof(head1));1508
s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);1509
s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));1510
stbiw__putc(s, 0x10); // HTYACinfo1511
s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);1512
s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));1513
stbiw__putc(s, 1); // HTUDCinfo1514
s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);1515
s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));1516
stbiw__putc(s, 0x11); // HTUACinfo1517
s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);1518
s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));1519
s->func(s->context, (void*)head2, sizeof(head2));1520
}1522
// Encode 8x8 macroblocks1523
{1524
static const unsigned short fillBits[] = {0x7F, 7};1525
int DCY=0, DCU=0, DCV=0;1526
int bitBuf=0, bitCnt=0;1527
// comp == 2 is grey+alpha (alpha is ignored)1528
int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;1529
const unsigned char *dataR = (const unsigned char *)data;1530
const unsigned char *dataG = dataR + ofsG;1531
const unsigned char *dataB = dataR + ofsB;1532
int x, y, pos;1533
if(subsample) {1534
for(y = 0; y < height; y += 16) {1535
for(x = 0; x < width; x += 16) {1536
float Y[256], U[256], V[256];1537
for(row = y, pos = 0; row < y+16; ++row) {1538
// row >= height => use last input row1539
int clamped_row = (row < height) ? row : height - 1;1540
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;1541
for(col = x; col < x+16; ++col, ++pos) {1542
// if col >= width => use pixel from last input column1543
int p = base_p + ((col < width) ? col : (width-1))*comp;1544
float r = dataR[p], g = dataG[p], b = dataB[p];1545
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;1546
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;1547
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;1548
}1549
}1550
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);1551
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);1552
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);1553
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);1555
// subsample U,V1556
{1557
float subU[64], subV[64];1558
int yy, xx;1559
for(yy = 0, pos = 0; yy < 8; ++yy) {1560
for(xx = 0; xx < 8; ++xx, ++pos) {1561
int j = yy*32+xx*2;1562
subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;1563
subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;1564
}1565
}1566
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);1567
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);1568
}1569
}1570
}1571
} else {1572
for(y = 0; y < height; y += 8) {1573
for(x = 0; x < width; x += 8) {1574
float Y[64], U[64], V[64];1575
for(row = y, pos = 0; row < y+8; ++row) {1576
// row >= height => use last input row1577
int clamped_row = (row < height) ? row : height - 1;1578
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;1579
for(col = x; col < x+8; ++col, ++pos) {1580
// if col >= width => use pixel from last input column1581
int p = base_p + ((col < width) ? col : (width-1))*comp;1582
float r = dataR[p], g = dataG[p], b = dataB[p];1583
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;1584
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;1585
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;1586
}1587
}1589
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT);1590
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);1591
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);1592
}1593
}1594
}1596
// Do the bit alignment of the EOI marker1597
stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);1598
}1600
// EOI1601
stbiw__putc(s, 0xFF);1602
stbiw__putc(s, 0xD9);1604
return 1;1605
}1607
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)1608
{1609
stbi__write_context s = { 0 };1610
stbi__start_write_callbacks(&s, func, context);1611
return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);1612
}1615
#ifndef STBI_WRITE_NO_STDIO1616
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)1617
{1618
stbi__write_context s = { 0 };1619
if (stbi__start_write_file(&s,filename)) {1620
int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);1621
stbi__end_write_file(&s);1622
return r;1623
} else1624
return 0;1625
}1626
#endif1628
#endif // STB_IMAGE_WRITE_IMPLEMENTATION1630
/* Revision history1631
1.16 (2021-07-11)1632
make Deflate code emit uncompressed blocks when it would otherwise expand1633
support writing BMPs with alpha channel1634
1.15 (2020-07-13) unknown1635
1.14 (2020-02-02) updated JPEG writer to downsample chroma channels1636
1.131637
1.121638
1.11 (2019-08-11)1640
1.10 (2019-02-07)1641
support utf8 filenames in Windows; fix warnings and platform ifdefs1642
1.09 (2018-02-11)1643
fix typo in zlib quality API, improve STB_I_W_STATIC in C++1644
1.08 (2018-01-29)1645
add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter1646
1.07 (2017-07-24)1647
doc fix1648
1.06 (2017-07-23)1649
writing JPEG (using Jon Olick's code)1650
1.05 ???1651
1.04 (2017-03-03)1652
monochrome BMP expansion1653
1.03 ???1654
1.02 (2016-04-02)1655
avoid allocating large structures on the stack1656
1.01 (2016-01-16)1657
STBIW_REALLOC_SIZED: support allocators with no realloc support1658
avoid race-condition in crc initialization1659
minor compile issues1660
1.00 (2015-09-14)1661
installable file IO function1662
0.99 (2015-09-13)1663
warning fixes; TGA rle support1664
0.98 (2015-04-08)1665
added STBIW_MALLOC, STBIW_ASSERT etc1666
0.97 (2015-01-18)1667
fixed HDR asserts, rewrote HDR rle logic1668
0.96 (2015-01-17)1669
add HDR output1670
fix monochrome BMP1671
0.95 (2014-08-17)1672
add monochrome TGA output1673
0.94 (2014-05-31)1674
rename private functions to avoid conflicts with stb_image.h1675
0.93 (2014-05-27)1676
warning fixes1677
0.92 (2010-08-01)1678
casts to unsigned char to fix warnings1679
0.91 (2010-07-17)1680
first public release1681
0.90 first internal release1682
*/1684
/*1685
------------------------------------------------------------------------------1686
This software is available under 2 licenses -- choose whichever you prefer.1687
------------------------------------------------------------------------------1688
ALTERNATIVE A - MIT License1689
Copyright (c) 2017 Sean Barrett1690
Permission is hereby granted, free of charge, to any person obtaining a copy of1691
this software and associated documentation files (the "Software"), to deal in1692
the Software without restriction, including without limitation the rights to1693
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies1694
of the Software, and to permit persons to whom the Software is furnished to do1695
so, subject to the following conditions:1696
The above copyright notice and this permission notice shall be included in all1697
copies or substantial portions of the Software.1698
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR1699
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,1700
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE1701
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER1702
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,1703
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE1704
SOFTWARE.1705
------------------------------------------------------------------------------1706
ALTERNATIVE B - Public Domain (www.unlicense.org)1707
This is free and unencumbered software released into the public domain.1708
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this1709
software, either in source code form or as a compiled binary, for any purpose,1710
commercial or non-commercial, and by any means.1711
In jurisdictions that recognize copyright laws, the author or authors of this1712
software dedicate any and all copyright interest in the software to the public1713
domain. We make this dedication for the benefit of the public at large and to1714
the detriment of our heirs and successors. We intend this dedication to be an1715
overt act of relinquishment in perpetuity of all present and future rights to1716
this software under copyright law.1717
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR1718
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,1719
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE1720
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN1721
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION1722
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.1723
------------------------------------------------------------------------------1724
*/