Oolite 1.91.0.7646-241128-10e222e
Loading...
Searching...
No Matches
stb_image_write.h
Go to the documentation of this file.
1/* stb_image_write - v1.16 - public domain - http://nothings.org/stb
2 writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
3 no warranty implied; use at your own risk
4
5 Before #including,
6
7 #define STB_IMAGE_WRITE_IMPLEMENTATION
8
9 in the file that you want to have the implementation.
10
11 Will probably not work correctly with strict-aliasing optimizations.
12
13ABOUT:
14
15 This header file is a library for writing images to C stdio or a callback.
16
17 The PNG output is not optimal; it is 20-50% larger than the file
18 written by a decent optimizing implementation; though providing a custom
19 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.
22
23BUILDING:
24
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 replace
27 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 function
30 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),
34
35UNICODE:
36
37 If compiling for Windows and you wish to use Unicode filenames, compile
38 with
39 #define STBIW_WINDOWS_UTF8
40 and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
41 Windows wchar_t filenames to utf8.
42
43USAGE:
44
45 There are five functions, one for each image file format:
46
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);
52
53 void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically
54
55 There are also five equivalent functions that use an arbitrary write function. You are
56 expected to open/close your file-equivalent before and after calling these:
57
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);
63
64 where the callback is:
65 void stbi_write_func(void *context, void *data, int size);
66
67 You can configure it with these global variables:
68 int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE
69 int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression
70 int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode
71
72
73 You can define STBI_WRITE_NO_STDIO to disable the file variant of these
74 functions, so the library will not use stdio.h at all. However, this will
75 also disable HDR writing, because it requires stdio for formatted output.
76
77 Each function returns 0 on failure and non-0 on success.
78
79 The functions create an image file defined by the parameters. The image
80 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-bits
82 per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
83 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 of
86 a row of pixels to the first byte of the next row of pixels.
87
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 not
90 output alpha.
91
92 PNG supports writing rectangles of data even when the bytes storing rows of
93 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 other
95 formats do not. (Thus you cannot write a native-format BMP through the BMP
96 writer, both because it is in BGR order and because it may have padding
97 at the end of the line.)
98
99 PNG allows you to set the deflate compression level by setting the global
100 variable 'stbi_write_png_compression_level' (it defaults to 8).
101
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 is
104 replicated across all three channels.
105
106 TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
107 data, set the global variable 'stbi_write_tga_with_rle' to 0.
108
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).
112
113CREDITS:
114
115
116 Sean Barrett - PNG/BMP/TGA
117 Baldur Karlsson - HDR
118 Jean-Sebastien Guay - TGA monochrome
119 Tim Kelsey - misc enhancements
120 Alan Hickman - TGA RLE
121 Emmanuel Julien - initial file IO callback implementation
122 Jon Olick - original jo_jpeg.cpp code
123 Daniel Gibson - integrate JPEG, allow external zlib
124 Aarni Koskela - allow choosing PNG filter
125
126 bugfixes:
127 github:Chribba
128 Guillaume Chereau
129 github:jry2
130 github:romigrou
131 Sergio Gonzalez
132 Jonas Karlsson
133 Filip Wasil
134 Thatcher Ulrich
135 github:poppolopoppo
136 Patrick Boettcher
137 github:xeekworx
138 Cap Petschulat
139 Simon Rodriguez
140 Ivan Tikhonov
141 github:ignotion
142 Adam Schackart
143 Andrew Kensler
144
145LICENSE
146
147 See end of file for license information.
148
149*/
150
151#ifndef INCLUDE_STB_IMAGE_WRITE_H
152#define INCLUDE_STB_IMAGE_WRITE_H
153
154#include <stdlib.h>
155
156// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
157#ifndef STBIWDEF
158#ifdef STB_IMAGE_WRITE_STATIC
159#define STBIWDEF static
160#else
161#ifdef __cplusplus
162#define STBIWDEF extern "C"
163#else
164#define STBIWDEF extern
165#endif
166#endif
167#endif
168
169#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations
170STBIWDEF int stbi_write_tga_with_rle;
171STBIWDEF int stbi_write_png_compression_level;
172STBIWDEF int stbi_write_force_png_filter;
173#endif
174
175#ifndef STBI_WRITE_NO_STDIO
176STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
177STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
178STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
179STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
180STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);
181
182#ifdef STBIW_WINDOWS_UTF8
183STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
184#endif
185#endif
186
187typedef void stbi_write_func(void *context, void *data, int size);
188
189STBIWDEF 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);
190STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
191STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data);
192STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data);
193STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality);
194
195STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
196
197#endif//INCLUDE_STB_IMAGE_WRITE_H
198
199#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
200
201#ifdef _WIN32
202 #ifndef _CRT_SECURE_NO_WARNINGS
203 #define _CRT_SECURE_NO_WARNINGS
204 #endif
205 #ifndef _CRT_NONSTDC_NO_DEPRECATE
206 #define _CRT_NONSTDC_NO_DEPRECATE
207 #endif
208#endif
209
210#ifndef STBI_WRITE_NO_STDIO
211#include <stdio.h>
212#endif // STBI_WRITE_NO_STDIO
213
214#include <stdarg.h>
215#include <stdlib.h>
216#include <string.h>
217#include <math.h>
218
219#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED))
220// ok
221#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED)
222// ok
223#else
224#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)."
225#endif
226
227#ifndef STBIW_MALLOC
228#define STBIW_MALLOC(sz) malloc(sz)
229#define STBIW_REALLOC(p,newsz) realloc(p,newsz)
230#define STBIW_FREE(p) free(p)
231#endif
232
233#ifndef STBIW_REALLOC_SIZED
234#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
235#endif
236
237
238#ifndef STBIW_MEMMOVE
239#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz)
240#endif
241
242
243#ifndef STBIW_ASSERT
244#include <assert.h>
245#define STBIW_ASSERT(x) assert(x)
246#endif
247
248#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
249
250#ifdef STB_IMAGE_WRITE_STATIC
251static int stbi_write_png_compression_level = 8;
252static int stbi_write_tga_with_rle = 1;
253static int stbi_write_force_png_filter = -1;
254#else
255int stbi_write_png_compression_level = 8;
256int stbi_write_tga_with_rle = 1;
257int stbi_write_force_png_filter = -1;
258#endif
259
260static int stbi__flip_vertically_on_write = 0;
261
262STBIWDEF void stbi_flip_vertically_on_write(int flag)
263{
264 stbi__flip_vertically_on_write = flag;
265}
266
267typedef struct
268{
269 stbi_write_func *func;
270 void *context;
271 unsigned char buffer[64];
272 int buf_used;
273} stbi__write_context;
274
275// initialize a callback-based context
276static 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}
281
282#ifndef STBI_WRITE_NO_STDIO
283
284static void stbi__stdio_write(void *context, void *data, int size)
285{
286 fwrite(data,1,size,(FILE*) context);
287}
288
289#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8)
290#ifdef __cplusplus
291#define STBIW_EXTERN extern "C"
292#else
293#define STBIW_EXTERN extern
294#endif
295STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
296STBIW_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);
297
298STBIWDEF 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#endif
303
304static 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;
312
313 if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
314 return 0;
315
316#if defined(_MSC_VER) && _MSC_VER >= 1400
317 if (0 != _wfopen_s(&f, wFilename, wMode))
318 f = 0;
319#else
320 f = _wfopen(wFilename, wMode);
321#endif
322
323#elif defined(_MSC_VER) && _MSC_VER >= 1400
324 if (0 != fopen_s(&f, filename, mode))
325 f=0;
326#else
327 f = fopen(filename, mode);
328#endif
329 return f;
330}
331
332static 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}
338
339static void stbi__end_write_file(stbi__write_context *s)
340{
341 fclose((FILE *)s->context);
342}
343
344#endif // !STBI_WRITE_NO_STDIO
345
346typedef unsigned int stbiw_uint32;
347typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
348
349static 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}
377
378static 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}
385
386static 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}
393
394static void stbiw__putc(stbi__write_context *s, unsigned char c)
395{
396 s->func(s->context, &c, 1);
397}
398
399static 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}
405
406static 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}
417
418static 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;
422
423 if (write_alpha < 0)
424 stbiw__write1(s, d[comp - 1]);
425
426 switch (comp) {
427 case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
428 case 1:
429 if (expand_mono)
430 stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
431 else
432 stbiw__write1(s, d[0]); // monochrome TGA
433 break;
434 case 4:
435 if (!write_alpha) {
436 // composite against pink background
437 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}
450
451static 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;
455
456 if (y <= 0)
457 return;
458
459 if (stbi__flip_vertically_on_write)
460 vdir *= -1;
461
462 if (vdir < 0) {
463 j_end = -1; j = y-1;
464 } else {
465 j_end = y; j = 0;
466 }
467
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}
477
478static 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}
491
492static 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 bitmap
496 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 header
500 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header
501 } else {
502 // RGBA bitmaps need a v4 header
503 // use BI_BITFIELDS mode with 32bpp and alpha mask
504 // (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 header
508 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 header
509 }
510}
511
512STBIWDEF 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}
518
519#ifndef STBI_WRITE_NO_STDIO
520STBIWDEF 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 } else
528 return 0;
529}
530#endif
531
532static 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) = 3
537
538 if (y < 0 || x < 0)
539 return 0;
540
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;
547
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);
549
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;
562
563 for (i = 0; i < x; i += len) {
564 unsigned char *begin = row + i * comp;
565 int diff = 1;
566 len = 1;
567
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 }
592
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}
610
611STBIWDEF 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}
617
618#ifndef STBI_WRITE_NO_STDIO
619STBIWDEF 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 } else
627 return 0;
628}
629#endif
630
631// *************************************************************************************************
632// Radiance RGBE HDR writer
633// by Baldur Karlsson
634
635#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))
636
637#ifndef STBI_WRITE_NO_STDIO
638
639static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
640{
641 int exponent, i;
642 float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
643
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;
648
649 // ensure that any non-Rec709 colors are clamped to Rec709
650 for (i = 0; i < 3; i++)
651 {
652 if (linear[i] < 0.0f) linear[i] = 0.0f;
653 }
654
655 rgbe[0] = (unsigned char)(linear[0] * normalize);
656 rgbe[1] = (unsigned char)(linear[1] * normalize);
657 rgbe[2] = (unsigned char)(linear[2] * normalize);
658 rgbe[3] = (unsigned char)(exponent + 128);
659 }
660}
661
662static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
663{
664 unsigned char lengthbyte = STBIW_UCHAR(length+128);
665 STBIW_ASSERT(length+128 <= 255);
666 s->func(s->context, &lengthbyte, 1);
667 s->func(s->context, &databyte, 1);
668}
669
670static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
671{
672 unsigned char lengthbyte = STBIW_UCHAR(length);
673 STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
674 s->func(s->context, &lengthbyte, 1);
675 s->func(s->context, data, length);
676}
677
678static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
679{
680 unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
681 unsigned char rgbe[4];
682 float linear[3];
683 int x;
684
685 scanlineheader[2] = (width&0xff00)>>8;
686 scanlineheader[3] = (width&0x00ff);
687
688 /* skip RLE for images too small or large */
689 if (width < 8 || width >= 32768) {
690 for (x=0; x < width; x++) {
691 switch (ncomp) {
692 case 4: /* fallthrough */
693 case 3: linear[2] = scanline[x*ncomp + 2];
694 linear[1] = scanline[x*ncomp + 1];
695 linear[0] = scanline[x*ncomp + 0];
696 break;
697 default:
698 linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
699 break;
700 }
701 stbiw__linear_to_rgbe(rgbe, linear);
702 s->func(s->context, rgbe, 4);
703 }
704 } else {
705 int c,r;
706 /* encode into scratch buffer */
707 for (x=0; x < width; x++) {
708 switch(ncomp) {
709 case 4: /* fallthrough */
710 case 3: linear[2] = scanline[x*ncomp + 2];
711 linear[1] = scanline[x*ncomp + 1];
712 linear[0] = scanline[x*ncomp + 0];
713 break;
714 default:
715 linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0];
716 break;
717 }
718 stbiw__linear_to_rgbe(rgbe, linear);
719 scratch[x + width*0] = rgbe[0];
720 scratch[x + width*1] = rgbe[1];
721 scratch[x + width*2] = rgbe[2];
722 scratch[x + width*3] = rgbe[3];
723 }
724
725 s->func(s->context, scanlineheader, 4);
726
727 /* RLE each component separately */
728 for (c=0; c < 4; c++) {
729 unsigned char *comp = &scratch[width*c];
730
731 x = 0;
732 while (x < width) {
733 // find first run
734 r = x;
735 while (r+2 < width) {
736 if (comp[r] == comp[r+1] && comp[r] == comp[r+2])
737 break;
738 ++r;
739 }
740 if (r+2 >= width)
741 r = width;
742 // dump up to first run
743 while (x < r) {
744 int len = r-x;
745 if (len > 128) len = 128;
746 stbiw__write_dump_data(s, len, &comp[x]);
747 x += len;
748 }
749 // if there's a run, output it
750 if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
751 // find next byte after run
752 while (r < width && comp[r] == comp[x])
753 ++r;
754 // output run up to r
755 while (x < r) {
756 int len = r-x;
757 if (len > 127) len = 127;
758 stbiw__write_run_data(s, len, comp[x]);
759 x += len;
760 }
761 }
762 }
763 }
764 }
765}
766
767static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
768{
769 if (y <= 0 || x <= 0 || data == NULL)
770 return 0;
771 else {
772 // Each component is stored separately. Allocate scratch space for full output scanline.
773 unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
774 int i, len;
775 char buffer[128];
776 char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
777 s->func(s->context, header, sizeof(header)-1);
778
779#ifdef __STDC_LIB_EXT1__
780 len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
781#else
782 len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
783#endif
784 s->func(s->context, buffer, len);
785
786 for(i=0; i < y; i++)
787 stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
788 STBIW_FREE(scratch);
789 return 1;
790 }
791}
792
793STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
794{
795 stbi__write_context s = { 0 };
796 stbi__start_write_callbacks(&s, func, context);
797 return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
798}
799
800STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
801{
802 stbi__write_context s = { 0 };
803 if (stbi__start_write_file(&s,filename)) {
804 int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
805 stbi__end_write_file(&s);
806 return r;
807 } else
808 return 0;
809}
810#endif // STBI_WRITE_NO_STDIO
811
812
814//
815// PNG writer
816//
817
818#ifndef STBIW_ZLIB_COMPRESS
819// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
820#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
821#define stbiw__sbm(a) stbiw__sbraw(a)[0]
822#define stbiw__sbn(a) stbiw__sbraw(a)[1]
823
824#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a))
825#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0)
826#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a)))
827
828#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v))
829#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0)
830#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0)
831
832static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
833{
834 int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
835 void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
836 STBIW_ASSERT(p);
837 if (p) {
838 if (!*arr) ((int *) p)[1] = 0;
839 *arr = (void *) ((int *) p + 2);
840 stbiw__sbm(*arr) = m;
841 }
842 return *arr;
843}
844
845static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
846{
847 while (*bitcount >= 8) {
848 stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
849 *bitbuffer >>= 8;
850 *bitcount -= 8;
851 }
852 return data;
853}
854
855static int stbiw__zlib_bitrev(int code, int codebits)
856{
857 int res=0;
858 while (codebits--) {
859 res = (res << 1) | (code & 1);
860 code >>= 1;
861 }
862 return res;
863}
864
865static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
866{
867 int i;
868 for (i=0; i < limit && i < 258; ++i)
869 if (a[i] != b[i]) break;
870 return i;
871}
872
873static unsigned int stbiw__zhash(unsigned char *data)
874{
875 stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
876 hash ^= hash << 3;
877 hash += hash >> 5;
878 hash ^= hash << 4;
879 hash += hash >> 17;
880 hash ^= hash << 25;
881 hash += hash >> 6;
882 return hash;
883}
884
885#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount))
886#define stbiw__zlib_add(code,codebits) \
887 (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush())
888#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c)
889// default huffman tables
890#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)
891#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)
892#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7)
893#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8)
894#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))
895#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n))
896
897#define stbiw__ZHASH 16384
898
899#endif // STBIW_ZLIB_COMPRESS
900
901STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
902{
903#ifdef STBIW_ZLIB_COMPRESS
904 // user provided a zlib compress implementation, use that
905 return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
906#else // use builtin
907 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 };
908 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 };
909 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 };
910 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 };
911 unsigned int bitbuf=0;
912 int i,j, bitcount=0;
913 unsigned char *out = NULL;
914 unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));
915 if (hash_table == NULL)
916 return NULL;
917 if (quality < 5) quality = 5;
918
919 stbiw__sbpush(out, 0x78); // DEFLATE 32K window
920 stbiw__sbpush(out, 0x5e); // FLEVEL = 1
921 stbiw__zlib_add(1,1); // BFINAL = 1
922 stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman
923
924 for (i=0; i < stbiw__ZHASH; ++i)
925 hash_table[i] = NULL;
926
927 i=0;
928 while (i < data_len-3) {
929 // hash next 3 bytes of data to be compressed
930 int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3;
931 unsigned char *bestloc = 0;
932 unsigned char **hlist = hash_table[h];
933 int n = stbiw__sbcount(hlist);
934 for (j=0; j < n; ++j) {
935 if (hlist[j]-data > i-32768) { // if entry lies within window
936 int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
937 if (d >= best) { best=d; bestloc=hlist[j]; }
938 }
939 }
940 // when hash table entry is too long, delete half the entries
941 if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) {
942 STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
943 stbiw__sbn(hash_table[h]) = quality;
944 }
945 stbiw__sbpush(hash_table[h],data+i);
946
947 if (bestloc) {
948 // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
949 h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1);
950 hlist = hash_table[h];
951 n = stbiw__sbcount(hlist);
952 for (j=0; j < n; ++j) {
953 if (hlist[j]-data > i-32767) {
954 int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1);
955 if (e > best) { // if next match is better, bail on current match
956 bestloc = NULL;
957 break;
958 }
959 }
960 }
961 }
962
963 if (bestloc) {
964 int d = (int) (data+i - bestloc); // distance back
965 STBIW_ASSERT(d <= 32767 && best <= 258);
966 for (j=0; best > lengthc[j+1]-1; ++j);
967 stbiw__zlib_huff(j+257);
968 if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
969 for (j=0; d > distc[j+1]-1; ++j);
970 stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5);
971 if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
972 i += best;
973 } else {
974 stbiw__zlib_huffb(data[i]);
975 ++i;
976 }
977 }
978 // write out final bytes
979 for (;i < data_len; ++i)
980 stbiw__zlib_huffb(data[i]);
981 stbiw__zlib_huff(256); // end of block
982 // pad with 0 bits to byte boundary
983 while (bitcount)
984 stbiw__zlib_add(0,1);
985
986 for (i=0; i < stbiw__ZHASH; ++i)
987 (void) stbiw__sbfree(hash_table[i]);
988 STBIW_FREE(hash_table);
989
990 // store uncompressed instead if compression was worse
991 if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {
992 stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1
993 for (j = 0; j < data_len;) {
994 int blocklen = data_len - j;
995 if (blocklen > 32767) blocklen = 32767;
996 stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression
997 stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN
998 stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
999 stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN
1000 stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8));
1001 memcpy(out+stbiw__sbn(out), data+j, blocklen);
1002 stbiw__sbn(out) += blocklen;
1003 j += blocklen;
1004 }
1005 }
1006
1007 {
1008 // compute adler32 on input
1009 unsigned int s1=1, s2=0;
1010 int blocklen = (int) (data_len % 5552);
1011 j=0;
1012 while (j < data_len) {
1013 for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }
1014 s1 %= 65521; s2 %= 65521;
1015 j += blocklen;
1016 blocklen = 5552;
1017 }
1018 stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8));
1019 stbiw__sbpush(out, STBIW_UCHAR(s2));
1020 stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8));
1021 stbiw__sbpush(out, STBIW_UCHAR(s1));
1022 }
1023 *out_len = stbiw__sbn(out);
1024 // make returned pointer freeable
1025 STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
1026 return (unsigned char *) stbiw__sbraw(out);
1027#endif // STBIW_ZLIB_COMPRESS
1028}
1029
1030static unsigned int stbiw__crc32(unsigned char *buffer, int len)
1031{
1032#ifdef STBIW_CRC32
1033 return STBIW_CRC32(buffer, len);
1034#else
1035 static unsigned int crc_table[256] =
1036 {
1037 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
1038 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
1039 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
1040 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
1041 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
1042 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
1043 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
1044 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
1045 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
1046 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
1047 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
1048 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
1049 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
1050 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
1051 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
1052 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
1053 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
1054 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
1055 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
1056 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
1057 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
1058 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
1059 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
1060 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
1061 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
1062 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
1063 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
1064 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
1065 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
1066 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
1067 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
1068 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
1069 };
1070
1071 unsigned int crc = ~0u;
1072 int i;
1073 for (i=0; i < len; ++i)
1074 crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
1075 return ~crc;
1076#endif
1077}
1078
1079#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)
1080#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
1081#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3])
1082
1083static void stbiw__wpcrc(unsigned char **data, int len)
1084{
1085 unsigned int crc = stbiw__crc32(*data - len - 4, len+4);
1086 stbiw__wp32(*data, crc);
1087}
1088
1089static unsigned char stbiw__paeth(int a, int b, int c)
1090{
1091 int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
1092 if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
1093 if (pb <= pc) return STBIW_UCHAR(b);
1094 return STBIW_UCHAR(c);
1095}
1096
1097// @OPTIMIZE: provide an option that always forces left-predict or paeth predict
1098static 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)
1099{
1100 static int mapping[] = { 0,1,2,3,4 };
1101 static int firstmap[] = { 0,1,0,5,6 };
1102 int *mymap = (y != 0) ? mapping : firstmap;
1103 int i;
1104 int type = mymap[filter_type];
1105 unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
1106 int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
1107
1108 if (type==0) {
1109 memcpy(line_buffer, z, width*n);
1110 return;
1111 }
1112
1113 // first loop isn't optimized since it's just one pixel
1114 for (i = 0; i < n; ++i) {
1115 switch (type) {
1116 case 1: line_buffer[i] = z[i]; break;
1117 case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
1118 case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
1119 case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break;
1120 case 5: line_buffer[i] = z[i]; break;
1121 case 6: line_buffer[i] = z[i]; break;
1122 }
1123 }
1124 switch (type) {
1125 case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
1126 case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
1127 case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
1128 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;
1129 case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
1130 case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
1131 }
1132}
1133
1134STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
1135{
1136 int force_filter = stbi_write_force_png_filter;
1137 int ctype[5] = { -1, 0, 4, 2, 6 };
1138 unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
1139 unsigned char *out,*o, *filt, *zlib;
1140 signed char *line_buffer;
1141 int j,zlen;
1142
1143 if (stride_bytes == 0)
1144 stride_bytes = x * n;
1145
1146 if (force_filter >= 5) {
1147 force_filter = -1;
1148 }
1149
1150 filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
1151 line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
1152 for (j=0; j < y; ++j) {
1153 int filter_type;
1154 if (force_filter > -1) {
1155 filter_type = force_filter;
1156 stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
1157 } else { // Estimate the best filter by running through all of them:
1158 int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
1159 for (filter_type = 0; filter_type < 5; filter_type++) {
1160 stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
1161
1162 // Estimate the entropy of the line using this filter; the less, the better.
1163 est = 0;
1164 for (i = 0; i < x*n; ++i) {
1165 est += abs((signed char) line_buffer[i]);
1166 }
1167 if (est < best_filter_val) {
1168 best_filter_val = est;
1169 best_filter = filter_type;
1170 }
1171 }
1172 if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it
1173 stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
1174 filter_type = best_filter;
1175 }
1176 }
1177 // when we get here, filter_type contains the filter type, and line_buffer contains the data
1178 filt[j*(x*n+1)] = (unsigned char) filter_type;
1179 STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
1180 }
1181 STBIW_FREE(line_buffer);
1182 zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level);
1183 STBIW_FREE(filt);
1184 if (!zlib) return 0;
1185
1186 // each tag requires 12 bytes of overhead
1187 out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
1188 if (!out) return 0;
1189 *out_len = 8 + 12+13 + 12+zlen + 12;
1190
1191 o=out;
1192 STBIW_MEMMOVE(o,sig,8); o+= 8;
1193 stbiw__wp32(o, 13); // header length
1194 stbiw__wptag(o, "IHDR");
1195 stbiw__wp32(o, x);
1196 stbiw__wp32(o, y);
1197 *o++ = 8;
1198 *o++ = STBIW_UCHAR(ctype[n]);
1199 *o++ = 0;
1200 *o++ = 0;
1201 *o++ = 0;
1202 stbiw__wpcrc(&o,13);
1203
1204 stbiw__wp32(o, zlen);
1205 stbiw__wptag(o, "IDAT");
1206 STBIW_MEMMOVE(o, zlib, zlen);
1207 o += zlen;
1208 STBIW_FREE(zlib);
1209 stbiw__wpcrc(&o, zlen);
1210
1211 stbiw__wp32(o,0);
1212 stbiw__wptag(o, "IEND");
1213 stbiw__wpcrc(&o,0);
1214
1215 STBIW_ASSERT(o == out + *out_len);
1216
1217 return out;
1218}
1219
1220#ifndef STBI_WRITE_NO_STDIO
1221STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
1222{
1223 FILE *f;
1224 int len;
1225 unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
1226 if (png == NULL) return 0;
1227
1228 f = stbiw__fopen(filename, "wb");
1229 if (!f) { STBIW_FREE(png); return 0; }
1230 fwrite(png, 1, len, f);
1231 fclose(f);
1232 STBIW_FREE(png);
1233 return 1;
1234}
1235#endif
1236
1237STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
1238{
1239 int len;
1240 unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
1241 if (png == NULL) return 0;
1242 func(context, png, len);
1243 STBIW_FREE(png);
1244 return 1;
1245}
1246
1247
1248/* ***************************************************************************
1249 *
1250 * JPEG writer
1251 *
1252 * This is based on Jon Olick's jo_jpeg.cpp:
1253 * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
1254 */
1255
1256static 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,
1257 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 };
1258
1259static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
1260 int bitBuf = *bitBufP, bitCnt = *bitCntP;
1261 bitCnt += bs[1];
1262 bitBuf |= bs[0] << (24 - bitCnt);
1263 while(bitCnt >= 8) {
1264 unsigned char c = (bitBuf >> 16) & 255;
1265 stbiw__putc(s, c);
1266 if(c == 255) {
1267 stbiw__putc(s, 0);
1268 }
1269 bitBuf <<= 8;
1270 bitCnt -= 8;
1271 }
1272 *bitBufP = bitBuf;
1273 *bitCntP = bitCnt;
1274}
1275
1276static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
1277 float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
1278 float z1, z2, z3, z4, z5, z11, z13;
1279
1280 float tmp0 = d0 + d7;
1281 float tmp7 = d0 - d7;
1282 float tmp1 = d1 + d6;
1283 float tmp6 = d1 - d6;
1284 float tmp2 = d2 + d5;
1285 float tmp5 = d2 - d5;
1286 float tmp3 = d3 + d4;
1287 float tmp4 = d3 - d4;
1288
1289 // Even part
1290 float tmp10 = tmp0 + tmp3; // phase 2
1291 float tmp13 = tmp0 - tmp3;
1292 float tmp11 = tmp1 + tmp2;
1293 float tmp12 = tmp1 - tmp2;
1294
1295 d0 = tmp10 + tmp11; // phase 3
1296 d4 = tmp10 - tmp11;
1297
1298 z1 = (tmp12 + tmp13) * 0.707106781f; // c4
1299 d2 = tmp13 + z1; // phase 5
1300 d6 = tmp13 - z1;
1301
1302 // Odd part
1303 tmp10 = tmp4 + tmp5; // phase 2
1304 tmp11 = tmp5 + tmp6;
1305 tmp12 = tmp6 + tmp7;
1306
1307 // The rotator is modified from fig 4-8 to avoid extra negations.
1308 z5 = (tmp10 - tmp12) * 0.382683433f; // c6
1309 z2 = tmp10 * 0.541196100f + z5; // c2-c6
1310 z4 = tmp12 * 1.306562965f + z5; // c2+c6
1311 z3 = tmp11 * 0.707106781f; // c4
1312
1313 z11 = tmp7 + z3; // phase 5
1314 z13 = tmp7 - z3;
1315
1316 *d5p = z13 + z2; // phase 6
1317 *d3p = z13 - z2;
1318 *d1p = z11 + z4;
1319 *d7p = z11 - z4;
1320
1321 *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6;
1322}
1323
1324static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
1325 int tmp1 = val < 0 ? -val : val;
1326 val = val < 0 ? val-1 : val;
1327 bits[1] = 1;
1328 while(tmp1 >>= 1) {
1329 ++bits[1];
1330 }
1331 bits[0] = val & ((1<<bits[1])-1);
1332}
1333
1334static 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]) {
1335 const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
1336 const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
1337 int dataOff, i, j, n, diff, end0pos, x, y;
1338 int DU[64];
1339
1340 // DCT rows
1341 for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
1342 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]);
1343 }
1344 // DCT columns
1345 for(dataOff=0; dataOff<8; ++dataOff) {
1346 stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
1347 &CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
1348 }
1349 // Quantize/descale/zigzag the coefficients
1350 for(y = 0, j=0; y < 8; ++y) {
1351 for(x = 0; x < 8; ++x,++j) {
1352 float v;
1353 i = y*du_stride+x;
1354 v = CDU[i]*fdtbl[j];
1355 // DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
1356 // ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
1357 DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
1358 }
1359 }
1360
1361 // Encode DC
1362 diff = DU[0] - DC;
1363 if (diff == 0) {
1364 stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0]);
1365 } else {
1366 unsigned short bits[2];
1367 stbiw__jpg_calcBits(diff, bits);
1368 stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1]]);
1369 stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
1370 }
1371 // Encode ACs
1372 end0pos = 63;
1373 for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
1374 }
1375 // end0pos = first element in reverse order !=0
1376 if(end0pos == 0) {
1377 stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
1378 return DU[0];
1379 }
1380 for(i = 1; i <= end0pos; ++i) {
1381 int startpos = i;
1382 int nrzeroes;
1383 unsigned short bits[2];
1384 for (; DU[i]==0 && i<=end0pos; ++i) {
1385 }
1386 nrzeroes = i-startpos;
1387 if ( nrzeroes >= 16 ) {
1388 int lng = nrzeroes>>4;
1389 int nrmarker;
1390 for (nrmarker=1; nrmarker <= lng; ++nrmarker)
1391 stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes);
1392 nrzeroes &= 15;
1393 }
1394 stbiw__jpg_calcBits(DU[i], bits);
1395 stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]);
1396 stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits);
1397 }
1398 if(end0pos != 63) {
1399 stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB);
1400 }
1401 return DU[0];
1402}
1403
1404static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
1405 // Constants that don't pollute global namespace
1406 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};
1407 static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
1408 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};
1409 static const unsigned char std_ac_luminance_values[] = {
1410 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
1411 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
1412 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
1413 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
1414 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
1415 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
1416 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
1417 };
1418 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};
1419 static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
1420 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};
1421 static const unsigned char std_ac_chrominance_values[] = {
1422 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
1423 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
1424 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
1425 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
1426 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
1427 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
1428 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
1429 };
1430 // Huffman tables
1431 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}};
1432 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}};
1433 static const unsigned short YAC_HT[256][2] = {
1434 {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},
1435 {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},
1436 {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},
1437 {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},
1438 {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},
1439 {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},
1440 {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},
1441 {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},
1442 {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},
1443 {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},
1444 {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},
1445 {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},
1446 {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},
1447 {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},
1448 {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},
1449 {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}
1450 };
1451 static const unsigned short UVAC_HT[256][2] = {
1452 {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},
1453 {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},
1454 {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},
1455 {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},
1456 {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},
1457 {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},
1458 {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},
1459 {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},
1460 {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},
1461 {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},
1462 {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},
1463 {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},
1464 {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},
1465 {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},
1466 {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},
1467 {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}
1468 };
1469 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,
1470 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};
1471 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,
1472 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};
1473 static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
1474 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
1475
1476 int row, col, i, k, subsample;
1477 float fdtbl_Y[64], fdtbl_UV[64];
1478 unsigned char YTable[64], UVTable[64];
1479
1480 if(!data || !width || !height || comp > 4 || comp < 1) {
1481 return 0;
1482 }
1483
1484 quality = quality ? quality : 90;
1485 subsample = quality <= 90 ? 1 : 0;
1486 quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
1487 quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
1488
1489 for(i = 0; i < 64; ++i) {
1490 int uvti, yti = (YQT[i]*quality+50)/100;
1491 YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti);
1492 uvti = (UVQT[i]*quality+50)/100;
1493 UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti);
1494 }
1495
1496 for(row = 0, k = 0; row < 8; ++row) {
1497 for(col = 0; col < 8; ++col, ++k) {
1498 fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
1499 fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]);
1500 }
1501 }
1502
1503 // Write Headers
1504 {
1505 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 };
1506 static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
1507 const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
1508 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
1509 s->func(s->context, (void*)head0, sizeof(head0));
1510 s->func(s->context, (void*)YTable, sizeof(YTable));
1511 stbiw__putc(s, 1);
1512 s->func(s->context, UVTable, sizeof(UVTable));
1513 s->func(s->context, (void*)head1, sizeof(head1));
1514 s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1);
1515 s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values));
1516 stbiw__putc(s, 0x10); // HTYACinfo
1517 s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1);
1518 s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values));
1519 stbiw__putc(s, 1); // HTUDCinfo
1520 s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1);
1521 s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values));
1522 stbiw__putc(s, 0x11); // HTUACinfo
1523 s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1);
1524 s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values));
1525 s->func(s->context, (void*)head2, sizeof(head2));
1526 }
1527
1528 // Encode 8x8 macroblocks
1529 {
1530 static const unsigned short fillBits[] = {0x7F, 7};
1531 int DCY=0, DCU=0, DCV=0;
1532 int bitBuf=0, bitCnt=0;
1533 // comp == 2 is grey+alpha (alpha is ignored)
1534 int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
1535 const unsigned char *dataR = (const unsigned char *)data;
1536 const unsigned char *dataG = dataR + ofsG;
1537 const unsigned char *dataB = dataR + ofsB;
1538 int x, y, pos;
1539 if(subsample) {
1540 for(y = 0; y < height; y += 16) {
1541 for(x = 0; x < width; x += 16) {
1542 float Y[256], U[256], V[256];
1543 for(row = y, pos = 0; row < y+16; ++row) {
1544 // row >= height => use last input row
1545 int clamped_row = (row < height) ? row : height - 1;
1546 int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
1547 for(col = x; col < x+16; ++col, ++pos) {
1548 // if col >= width => use pixel from last input column
1549 int p = base_p + ((col < width) ? col : (width-1))*comp;
1550 float r = dataR[p], g = dataG[p], b = dataB[p];
1551 Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
1552 U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
1553 V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
1554 }
1555 }
1556 DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
1557 DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
1558 DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
1559 DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
1560
1561 // subsample U,V
1562 {
1563 float subU[64], subV[64];
1564 int yy, xx;
1565 for(yy = 0, pos = 0; yy < 8; ++yy) {
1566 for(xx = 0; xx < 8; ++xx, ++pos) {
1567 int j = yy*32+xx*2;
1568 subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;
1569 subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;
1570 }
1571 }
1572 DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
1573 DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
1574 }
1575 }
1576 }
1577 } else {
1578 for(y = 0; y < height; y += 8) {
1579 for(x = 0; x < width; x += 8) {
1580 float Y[64], U[64], V[64];
1581 for(row = y, pos = 0; row < y+8; ++row) {
1582 // row >= height => use last input row
1583 int clamped_row = (row < height) ? row : height - 1;
1584 int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
1585 for(col = x; col < x+8; ++col, ++pos) {
1586 // if col >= width => use pixel from last input column
1587 int p = base_p + ((col < width) ? col : (width-1))*comp;
1588 float r = dataR[p], g = dataG[p], b = dataB[p];
1589 Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
1590 U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
1591 V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
1592 }
1593 }
1594
1595 DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT);
1596 DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
1597 DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
1598 }
1599 }
1600 }
1601
1602 // Do the bit alignment of the EOI marker
1603 stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
1604 }
1605
1606 // EOI
1607 stbiw__putc(s, 0xFF);
1608 stbiw__putc(s, 0xD9);
1609
1610 return 1;
1611}
1612
1613STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
1614{
1615 stbi__write_context s = { 0 };
1616 stbi__start_write_callbacks(&s, func, context);
1617 return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
1618}
1619
1620
1621#ifndef STBI_WRITE_NO_STDIO
1622STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
1623{
1624 stbi__write_context s = { 0 };
1625 if (stbi__start_write_file(&s,filename)) {
1626 int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
1627 stbi__end_write_file(&s);
1628 return r;
1629 } else
1630 return 0;
1631}
1632#endif
1633
1634#endif // STB_IMAGE_WRITE_IMPLEMENTATION
1635
1636/* Revision history
1637 1.16 (2021-07-11)
1638 make Deflate code emit uncompressed blocks when it would otherwise expand
1639 support writing BMPs with alpha channel
1640 1.15 (2020-07-13) unknown
1641 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels
1642 1.13
1643 1.12
1644 1.11 (2019-08-11)
1645
1646 1.10 (2019-02-07)
1647 support utf8 filenames in Windows; fix warnings and platform ifdefs
1648 1.09 (2018-02-11)
1649 fix typo in zlib quality API, improve STB_I_W_STATIC in C++
1650 1.08 (2018-01-29)
1651 add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter
1652 1.07 (2017-07-24)
1653 doc fix
1654 1.06 (2017-07-23)
1655 writing JPEG (using Jon Olick's code)
1656 1.05 ???
1657 1.04 (2017-03-03)
1658 monochrome BMP expansion
1659 1.03 ???
1660 1.02 (2016-04-02)
1661 avoid allocating large structures on the stack
1662 1.01 (2016-01-16)
1663 STBIW_REALLOC_SIZED: support allocators with no realloc support
1664 avoid race-condition in crc initialization
1665 minor compile issues
1666 1.00 (2015-09-14)
1667 installable file IO function
1668 0.99 (2015-09-13)
1669 warning fixes; TGA rle support
1670 0.98 (2015-04-08)
1671 added STBIW_MALLOC, STBIW_ASSERT etc
1672 0.97 (2015-01-18)
1673 fixed HDR asserts, rewrote HDR rle logic
1674 0.96 (2015-01-17)
1675 add HDR output
1676 fix monochrome BMP
1677 0.95 (2014-08-17)
1678 add monochrome TGA output
1679 0.94 (2014-05-31)
1680 rename private functions to avoid conflicts with stb_image.h
1681 0.93 (2014-05-27)
1682 warning fixes
1683 0.92 (2010-08-01)
1684 casts to unsigned char to fix warnings
1685 0.91 (2010-07-17)
1686 first public release
1687 0.90 first internal release
1688*/
1689
1690/*
1691------------------------------------------------------------------------------
1692This software is available under 2 licenses -- choose whichever you prefer.
1693------------------------------------------------------------------------------
1694ALTERNATIVE A - MIT License
1695Copyright (c) 2017 Sean Barrett
1696Permission is hereby granted, free of charge, to any person obtaining a copy of
1697this software and associated documentation files (the "Software"), to deal in
1698the Software without restriction, including without limitation the rights to
1699use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
1700of the Software, and to permit persons to whom the Software is furnished to do
1701so, subject to the following conditions:
1702The above copyright notice and this permission notice shall be included in all
1703copies or substantial portions of the Software.
1704THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1705IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1706FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1707AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1708LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
1709OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1710SOFTWARE.
1711------------------------------------------------------------------------------
1712ALTERNATIVE B - Public Domain (www.unlicense.org)
1713This is free and unencumbered software released into the public domain.
1714Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
1715software, either in source code form or as a compiled binary, for any purpose,
1716commercial or non-commercial, and by any means.
1717In jurisdictions that recognize copyright laws, the author or authors of this
1718software dedicate any and all copyright interest in the software to the public
1719domain. We make this dedication for the benefit of the public at large and to
1720the detriment of our heirs and successors. We intend this dedication to be an
1721overt act of relinquishment in perpetuity of all present and future rights to
1722this software under copyright law.
1723THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1724IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1725FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1726AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1727ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
1728WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1729------------------------------------------------------------------------------
1730*/
y
float y
Definition OORingEffectEntity.m:49
x
float x
Definition OORingEffectEntity.m:49
size
voidpf void uLong size
Definition ioapi.h:134
filename
const char * filename
Definition ioapi.h:133
int
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
mode
const char int mode
Definition ioapi.h:133
STBIWDEF
#define STBIWDEF
Definition stb_image_write.h:164
stbi_write_hdr
STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data)
stbi_write_func
void stbi_write_func(void *context, void *data, int size)
Definition stb_image_write.h:187
stbi_write_jpg
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
stbi_write_bmp
STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data)
stbi_write_png_compression_level
STBIWDEF int stbi_write_png_compression_level
Definition stb_image_write.h:171
stbi_write_force_png_filter
STBIWDEF int stbi_write_force_png_filter
Definition stb_image_write.h:172
stbi_flip_vertically_on_write
STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean)
stbi_write_tga_to_func
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data)
stbi_write_png_to_func
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)
stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes)
stbi_write_tga
STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data)
stbi_write_hdr_to_func
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data)
stbi_write_bmp_to_func
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data)
stbi_write_tga_with_rle
STBIWDEF int stbi_write_tga_with_rle
Definition stb_image_write.h:170
stbi_write_jpg_to_func
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
Generated by doxygen 1.12.0