stb_image_write.h 70 KB

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