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