GCC Code Coverage Report

Directory: ./
File: submodules/raylib/src/external/stb_image_write.h
Date: 2023-09-29 04:53:15
Exec Total Coverage
Lines: 0 588 0.0%
Branches: 0 439 0.0%
Line Branch Exec Source
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
13 ABOUT:
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
23 BUILDING:
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
35 UNICODE:
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
43 USAGE:
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
113 CREDITS:
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
145 LICENSE
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
170 STBIWDEF int stbi_write_tga_with_rle;
171 STBIWDEF int stbi_write_png_compression_level;
172 STBIWDEF int stbi_write_force_png_filter;
173 #endif
174
175 #ifndef STBI_WRITE_NO_STDIO
176 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);
181
182 #ifdef STBIW_WINDOWS_UTF8
183 STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
184 #endif
185 #endif
186
187 typedef void stbi_write_func(void *context, void *data, int size);
188
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);
194
195 STBIWDEF 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
251 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 #else
255 int stbi_write_png_compression_level = 8;
256 int stbi_write_tga_with_rle = 1;
257 int stbi_write_force_png_filter = -1;
258 #endif
259
260 static int stbi__flip_vertically_on_write = 0;
261
262 ✗ STBIWDEF void stbi_flip_vertically_on_write(int flag)
263 {
264 ✗ stbi__flip_vertically_on_write = flag;
265 }
266
267 typedef 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
276 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 }
281
282 #ifndef STBI_WRITE_NO_STDIO
283
284 ✗ static 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
295 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);
297
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 #endif
303
304 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;
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
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 }
338
339 static void stbi__end_write_file(stbi__write_context *s)
340 {
341 ✗ fclose((FILE *)s->context);
342 }
343
344 #endif // !STBI_WRITE_NO_STDIO
345
346 typedef unsigned int stbiw_uint32;
347 typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
348
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 }
377
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 }
385
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 }
393
394 static void stbiw__putc(stbi__write_context *s, unsigned char c)
395 {
396 ✗ s->func(s->context, &c, 1);
397 }
398
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 }
405
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 }
417
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;
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
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;
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
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 }
491
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 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
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 }
518
519 #ifndef STBI_WRITE_NO_STDIO
520 ✗ 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 } else
528 return 0;
529 }
530 #endif //!STBI_WRITE_NO_STDIO
531
532 ✗ 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) = 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
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 }
617
618 #ifndef STBI_WRITE_NO_STDIO
619 ✗ 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 } 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
639 ✗ 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]));
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 ✗ 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 }
655
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 }
663
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 code
668 ✗ s->func(s->context, &lengthbyte, 1);
669 ✗ s->func(s->context, data, length);
670 }
671
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;
678
679 ✗ scanlineheader[2] = (width&0xff00)>>8;
680 ✗ scanlineheader[3] = (width&0x00ff);
681
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 }
718
719 ✗ s->func(s->context, scanlineheader, 4);
720
721 /* RLE each component separately */
722 ✗ for (c=0; c < 4; c++) {
723 ✗ unsigned char *comp = &scratch[width*c];
724
725 x = 0;
726 ✗ while (x < width) {
727 // find first run
728 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 run
737 ✗ 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 it
744 ✗ if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd
745 // find next byte after run
746 ✗ while (r < width && comp[r] == comp[x])
747 ✗ ++r;
748 // output run up to r
749 ✗ 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 }
760
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);
772
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 #else
776 len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
777 #endif
778 ✗ s->func(s->context, buffer, len);
779
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 }
786
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 }
793
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 } else
802 return 0;
803 }
804 #endif // STBI_WRITE_NO_STDIO
805
806
807 //////////////////////////////////////////////////////////////////////////////
808 //
809 // PNG writer
810 //
811
812 #ifndef STBIW_ZLIB_COMPRESS
813 // 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]
817
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)))
821
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)
825
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 }
838
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 }
848
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 }
858
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 }
866
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 }
878
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 tables
884 #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))
890
891 #define stbiw__ZHASH 16384
892
893 #endif // STBIW_ZLIB_COMPRESS
894
895 ✗ STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
896 {
897 #ifdef STBIW_ZLIB_COMPRESS
898 // user provided a zlib compress implementation, use that
899 return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
900 #else // use builtin
901 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;
912
913 ✗ stbiw__sbpush(out, 0x78); // DEFLATE 32K window
914 ✗ stbiw__sbpush(out, 0x5e); // FLEVEL = 1
915 ✗ stbiw__zlib_add(1,1); // BFINAL = 1
916 ✗ stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman
917
918 ✗ for (i=0; i < stbiw__ZHASH; ++i)
919 ✗ hash_table[i] = NULL;
920
921 i=0;
922 ✗ while (i < data_len-3) {
923 // hash next 3 bytes of data to be compressed
924 ✗ 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 window
930 ✗ 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 entries
935 ✗ 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);
940
941 ✗ if (bestloc) {
942 // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
943 ✗ 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 match
950 bestloc = NULL;
951 break;
952 }
953 }
954 }
955 }
956
957 ✗ if (bestloc) {
958 ✗ int d = (int) (data+i - bestloc); // distance back
959 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 bytes
973 ✗ for (;i < data_len; ++i)
974 ✗ stbiw__zlib_huffb(data[i]);
975 ✗ stbiw__zlib_huff(256); // end of block
976 // pad with 0 bits to byte boundary
977 ✗ while (bitcount)
978 ✗ stbiw__zlib_add(0,1);
979
980 ✗ for (i=0; i < stbiw__ZHASH; ++i)
981 ✗ (void) stbiw__sbfree(hash_table[i]);
982 ✗ STBIW_FREE(hash_table);
983
984 // store uncompressed instead if compression was worse
985 ✗ if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) {
986 ✗ stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1
987 ✗ 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 compression
991 ✗ stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN
992 ✗ stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8));
993 ✗ stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN
994 ✗ 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 }
1000
1001 {
1002 // compute adler32 on input
1003 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 freeable
1019 ✗ STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len);
1020 ✗ return (unsigned char *) stbiw__sbraw(out);
1021 #endif // STBIW_ZLIB_COMPRESS
1022 }
1023
1024 static unsigned int stbiw__crc32(unsigned char *buffer, int len)
1025 {
1026 #ifdef STBIW_CRC32
1027 return STBIW_CRC32(buffer, len);
1028 #else
1029 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, 0x2D02EF8D
1063 };
1064
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 #endif
1071 }
1072
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])
1076
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 }
1082
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 }
1090
1091 // @OPTIMIZE: provide an option that always forces left-predict or paeth predict
1092 ✗ 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;
1101
1102 ✗ if (type==0) {
1103 ✗ memcpy(line_buffer, z, width*n);
1104 ✗ return;
1105 }
1106
1107 // first loop isn't optimized since it's just one pixel
1108 ✗ 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 }
1127
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;
1136
1137 ✗ if (stride_bytes == 0)
1138 ✗ stride_bytes = x * n;
1139
1140 ✗ if (force_filter >= 5) {
1141 force_filter = -1;
1142 }
1143
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);
1155
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 it
1167 ✗ 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 data
1172 ✗ 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;
1179
1180 // each tag requires 12 bytes of overhead
1181 ✗ 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;
1184
1185 o=out;
1186 ✗ STBIW_MEMMOVE(o,sig,8); o+= 8;
1187 ✗ stbiw__wp32(o, 13); // header length
1188 ✗ 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);
1197
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);
1204
1205 ✗ stbiw__wp32(o,0);
1206 ✗ stbiw__wptag(o, "IEND");
1207 ✗ stbiw__wpcrc(&o,0);
1208
1209 STBIW_ASSERT(o == out + *out_len);
1210
1211 ✗ return out;
1212 }
1213
1214 #ifndef STBI_WRITE_NO_STDIO
1215 ✗ 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;
1221
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 #endif
1230
1231 ✗ 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 }
1240
1241
1242 /* ***************************************************************************
1243 *
1244 * JPEG writer
1245 *
1246 * This is based on Jon Olick's jo_jpeg.cpp:
1247 * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html
1248 */
1249
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 };
1252
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 }
1269
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;
1273
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;
1282
1283 // Even part
1284 ✗ float tmp10 = tmp0 + tmp3; // phase 2
1285 ✗ float tmp13 = tmp0 - tmp3;
1286 ✗ float tmp11 = tmp1 + tmp2;
1287 ✗ float tmp12 = tmp1 - tmp2;
1288
1289 ✗ d0 = tmp10 + tmp11; // phase 3
1290 ✗ d4 = tmp10 - tmp11;
1291
1292 ✗ z1 = (tmp12 + tmp13) * 0.707106781f; // c4
1293 ✗ d2 = tmp13 + z1; // phase 5
1294 ✗ d6 = tmp13 - z1;
1295
1296 // Odd part
1297 ✗ tmp10 = tmp4 + tmp5; // phase 2
1298 ✗ tmp11 = tmp5 + tmp6;
1299 ✗ tmp12 = tmp6 + tmp7;
1300
1301 // The rotator is modified from fig 4-8 to avoid extra negations.
1302 ✗ z5 = (tmp10 - tmp12) * 0.382683433f; // c6
1303 ✗ z2 = tmp10 * 0.541196100f + z5; // c2-c6
1304 ✗ z4 = tmp12 * 1.306562965f + z5; // c2+c6
1305 ✗ z3 = tmp11 * 0.707106781f; // c4
1306
1307 ✗ z11 = tmp7 + z3; // phase 5
1308 ✗ z13 = tmp7 - z3;
1309
1310 ✗ *d5p = z13 + z2; // phase 6
1311 ✗ *d3p = z13 - z2;
1312 ✗ *d1p = z11 + z4;
1313 ✗ *d7p = z11 - z4;
1314
1315 ✗ *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6;
1316 }
1317
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 }
1327
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];
1333
1334 // DCT rows
1335 ✗ 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 columns
1339 ✗ 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 coefficients
1344 ✗ 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 }
1354
1355 // Encode DC
1356 ✗ 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 ACs
1366 end0pos = 63;
1367 ✗ for(; (end0pos>0)&&(DU[end0pos]==0); --end0pos) {
1368 }
1369 // end0pos = first element in reverse order !=0
1370 ✗ 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 }
1397
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 namespace
1400 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,0xfa
1411 };
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,0xfa
1423 };
1424 // Huffman tables
1425 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 };
1469
1470 int row, col, i, k, subsample;
1471 float fdtbl_Y[64], fdtbl_UV[64];
1472 unsigned char YTable[64], UVTable[64];
1473
1474 ✗ if(!data || !width || !height || comp > 4 || comp < 1) {
1475 return 0;
1476 }
1477
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;
1482
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 }
1489
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 }
1496
1497 // Write Headers
1498 {
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); // HTYACinfo
1511 ✗ 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); // HTUDCinfo
1514 ✗ 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); // HTUACinfo
1517 ✗ 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 }
1521
1522 // Encode 8x8 macroblocks
1523 {
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 row
1539 ✗ 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 column
1543 ✗ 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);
1554
1555 // subsample U,V
1556 {
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 row
1577 ✗ 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 column
1581 ✗ 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 }
1588
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 }
1595
1596 // Do the bit alignment of the EOI marker
1597 ✗ stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits);
1598 }
1599
1600 // EOI
1601 ✗ stbiw__putc(s, 0xFF);
1602 ✗ stbiw__putc(s, 0xD9);
1603
1604 ✗ return 1;
1605 }
1606
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 }
1613
1614
1615 #ifndef STBI_WRITE_NO_STDIO
1616 ✗ 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 } else
1624 return 0;
1625 }
1626 #endif
1627
1628 #endif // STB_IMAGE_WRITE_IMPLEMENTATION
1629
1630 /* Revision history
1631 1.16 (2021-07-11)
1632 make Deflate code emit uncompressed blocks when it would otherwise expand
1633 support writing BMPs with alpha channel
1634 1.15 (2020-07-13) unknown
1635 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels
1636 1.13
1637 1.12
1638 1.11 (2019-08-11)
1639
1640 1.10 (2019-02-07)
1641 support utf8 filenames in Windows; fix warnings and platform ifdefs
1642 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 filter
1646 1.07 (2017-07-24)
1647 doc fix
1648 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 expansion
1653 1.03 ???
1654 1.02 (2016-04-02)
1655 avoid allocating large structures on the stack
1656 1.01 (2016-01-16)
1657 STBIW_REALLOC_SIZED: support allocators with no realloc support
1658 avoid race-condition in crc initialization
1659 minor compile issues
1660 1.00 (2015-09-14)
1661 installable file IO function
1662 0.99 (2015-09-13)
1663 warning fixes; TGA rle support
1664 0.98 (2015-04-08)
1665 added STBIW_MALLOC, STBIW_ASSERT etc
1666 0.97 (2015-01-18)
1667 fixed HDR asserts, rewrote HDR rle logic
1668 0.96 (2015-01-17)
1669 add HDR output
1670 fix monochrome BMP
1671 0.95 (2014-08-17)
1672 add monochrome TGA output
1673 0.94 (2014-05-31)
1674 rename private functions to avoid conflicts with stb_image.h
1675 0.93 (2014-05-27)
1676 warning fixes
1677 0.92 (2010-08-01)
1678 casts to unsigned char to fix warnings
1679 0.91 (2010-07-17)
1680 first public release
1681 0.90 first internal release
1682 */
1683
1684 /*
1685 ------------------------------------------------------------------------------
1686 This software is available under 2 licenses -- choose whichever you prefer.
1687 ------------------------------------------------------------------------------
1688 ALTERNATIVE A - MIT License
1689 Copyright (c) 2017 Sean Barrett
1690 Permission is hereby granted, free of charge, to any person obtaining a copy of
1691 this software and associated documentation files (the "Software"), to deal in
1692 the Software without restriction, including without limitation the rights to
1693 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
1694 of the Software, and to permit persons to whom the Software is furnished to do
1695 so, subject to the following conditions:
1696 The above copyright notice and this permission notice shall be included in all
1697 copies or substantial portions of the Software.
1698 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1699 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1700 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1701 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1702 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 THE
1704 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 this
1709 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 this
1712 software dedicate any and all copyright interest in the software to the public
1713 domain. We make this dedication for the benefit of the public at large and to
1714 the detriment of our heirs and successors. We intend this dedication to be an
1715 overt act of relinquishment in perpetuity of all present and future rights to
1716 this software under copyright law.
1717 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1718 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1719 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1720 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1721 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
1722 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1723 ------------------------------------------------------------------------------
1724 */
1725