From a805b06406ae1247e0ccd42fe30a8163950778a9 Mon Sep 17 00:00:00 2001 From: Daniel Hammer Date: Sun, 22 Mar 2026 13:28:49 +0100 Subject: [PATCH] feat: add screenshot app --- programs/GNUmakefile | 18 +- programs/include/gui/stb_image_write.h | 1724 +++++++++++++++++ programs/lib/libjpegwrite/Makefile | 66 + programs/lib/libjpegwrite/libjpegwrite.a | Bin 0 -> 134080 bytes .../libjpegwrite/obj/stb_image_write_impl.o | Bin 0 -> 133576 bytes .../lib/libjpegwrite/stb_image_write_impl.c | 23 + programs/src/screenshot/Makefile | 93 + programs/src/screenshot/main.cpp | 168 ++ programs/src/screenshot/manifest.toml | 8 + scripts/install_apps.sh | 1 + 10 files changed, 2097 insertions(+), 4 deletions(-) create mode 100644 programs/include/gui/stb_image_write.h create mode 100644 programs/lib/libjpegwrite/Makefile create mode 100644 programs/lib/libjpegwrite/libjpegwrite.a create mode 100644 programs/lib/libjpegwrite/obj/stb_image_write_impl.o create mode 100644 programs/lib/libjpegwrite/stb_image_write_impl.c create mode 100644 programs/src/screenshot/Makefile create mode 100644 programs/src/screenshot/main.cpp create mode 100644 programs/src/screenshot/manifest.toml diff --git a/programs/GNUmakefile b/programs/GNUmakefile index c18f5e9..0205300 100644 --- a/programs/GNUmakefile +++ b/programs/GNUmakefile @@ -59,7 +59,7 @@ BINDIR := bin PROGRAMS := $(notdir $(wildcard src/*)) # Programs with custom Makefiles (built separately). -CUSTOM_BUILDS := doom fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth desktop login shell rpgdemo paint tcc +CUSTOM_BUILDS := doom fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth desktop login shell rpgdemo paint tcc screenshot SYSTEM_PROGRAMS := $(filter-out $(CUSTOM_BUILDS),$(PROGRAMS)) # Build targets: system programs go to bin/os/, apps go to bin/apps//. @@ -81,9 +81,9 @@ CA_CERTS := $(BINDIR)/etc/ca-certificates.crt # Common shared assets (wallpapers, etc.) COMMONKEEP := $(BINDIR)/common/.keep -.PHONY: all clean doom fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth login desktop shell rpgdemo paint tcc icons fonts bearssl libc tls libjpeg install-apps +.PHONY: all clean doom fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth login desktop shell rpgdemo paint tcc screenshot icons fonts bearssl libc tls libjpeg libjpegwrite install-apps -all: bearssl libc libjpeg tls $(TARGETS) fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth doom rpgdemo paint tcc login desktop shell icons fonts install-apps $(MANDST) $(WWWDST) $(CA_CERTS) $(COMMONKEEP) +all: bearssl libc libjpeg libjpegwrite tls $(TARGETS) fetch wiki wikipedia weather imageviewer fontpreview spreadsheet pdfviewer disks devexplorer installer volume music bluetooth doom rpgdemo paint tcc screenshot login desktop shell icons fonts install-apps $(MANDST) $(WWWDST) $(CA_CERTS) $(COMMONKEEP) # Build BearSSL static library (cross-compiled for freestanding x86_64). BEARSSL_INCLUDES := -isystem $(shell cd .. && pwd)/kernel/freestnd-c-hdrs/x86_64/include -isystem $(abspath include/libc) @@ -124,6 +124,10 @@ weather: bearssl libc tls libjpeg: libc $(MAKE) -C lib/libjpeg +# Build libjpegwrite static library (JPEG encoding via stb_image_write). +libjpegwrite: libc + $(MAKE) -C lib/libjpegwrite + # Build imageviewer standalone GUI client (depends on libc and libjpeg). imageviewer: libc libjpeg $(MAKE) -C src/imageviewer @@ -196,6 +200,10 @@ rpgdemo: libc doom: $(MAKE) -C src/doom +# Build screenshot tool (depends on libc and libjpegwrite). +screenshot: libc libjpegwrite + $(MAKE) -C src/screenshot + # Build TCC (Tiny C Compiler) via its own Makefile (depends on libc). tcc: libc $(MAKE) -C src/tcc @@ -206,7 +214,7 @@ tcc: libc cp include/libc/sys/*.h $(BINDIR)/lib/tcc/include/sys/ # Install app bundles (manifests, icons, data files) into bin/apps//. -install-apps: doom rpgdemo paint spreadsheet weather wikipedia imageviewer fontpreview pdfviewer disks devexplorer installer volume music bluetooth +install-apps: doom rpgdemo paint spreadsheet weather wikipedia imageviewer fontpreview pdfviewer disks devexplorer installer volume music bluetooth screenshot ../scripts/install_apps.sh # Copy man pages into bin/man/ so mkramdisk.sh picks them up. @@ -240,6 +248,7 @@ clean: $(MAKE) -C lib/bearssl clean $(MAKE) -C lib/libc clean $(MAKE) -C lib/libjpeg clean + $(MAKE) -C lib/libjpegwrite clean $(MAKE) -C lib/tls clean $(MAKE) -C src/fetch clean $(MAKE) -C src/doom clean @@ -260,4 +269,5 @@ clean: $(MAKE) -C src/bluetooth clean $(MAKE) -C src/paint clean $(MAKE) -C src/rpgdemo clean + $(MAKE) -C src/screenshot clean $(MAKE) -C src/tcc clean diff --git a/programs/include/gui/stb_image_write.h b/programs/include/gui/stb_image_write.h new file mode 100644 index 0000000..e4b32ed --- /dev/null +++ b/programs/include/gui/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + 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); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +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); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +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); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +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) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +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, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 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 + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + 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); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#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)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + 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 }; + 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 }; + 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 }; + 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 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#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) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +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) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + 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; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +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) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +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, + 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 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + 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}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + 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}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + 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}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + 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}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + 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}}; + 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}}; + static const unsigned short YAC_HT[256][2] = { + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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} + }; + static const unsigned short UVAC_HT[256][2] = { + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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} + }; + 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, + 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}; + 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, + 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}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + 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 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/programs/lib/libjpegwrite/Makefile b/programs/lib/libjpegwrite/Makefile new file mode 100644 index 0000000..3257aee --- /dev/null +++ b/programs/lib/libjpegwrite/Makefile @@ -0,0 +1,66 @@ +# Makefile for libjpegwrite (JPEG encoding via stb_image_write) on MontaukOS +# Copyright (c) 2026 Daniel Hammer + +MAKEFLAGS += -rR +.SUFFIXES: + +# ---- Toolchain ---- + +TOOLCHAIN_PREFIX := $(shell cd ../../.. && pwd)/toolchain/local/bin/x86_64-elf- +ifneq ($(wildcard $(TOOLCHAIN_PREFIX)gcc),) + CC := $(TOOLCHAIN_PREFIX)gcc + AR := $(TOOLCHAIN_PREFIX)ar +else + CC := gcc + AR := ar +endif + +# ---- Paths ---- + +LIBC_INC := ../../include/libc +PROG_INC := ../../include +OBJDIR := obj + +# ---- Compiler flags ---- + +CFLAGS := \ + -std=gnu11 \ + -g -O2 -pipe \ + -Wall \ + -Wno-unused-parameter \ + -Wno-unused-function \ + -nostdinc \ + -ffreestanding \ + -fno-stack-protector \ + -fno-stack-check \ + -fno-PIC \ + -ffunction-sections \ + -fdata-sections \ + -fno-tree-loop-distribute-patterns \ + -m64 \ + -march=x86-64 \ + -msse \ + -msse2 \ + -mno-red-zone \ + -mcmodel=small \ + -I $(PROG_INC) \ + -isystem $(LIBC_INC) \ + -isystem $(shell $(CC) -print-file-name=include) + +# ---- Target ---- + +TARGET := libjpegwrite.a + +.PHONY: all clean + +all: $(TARGET) + +$(TARGET): $(OBJDIR)/stb_image_write_impl.o + $(AR) rcs $@ $^ + +$(OBJDIR)/stb_image_write_impl.o: stb_image_write_impl.c Makefile + @mkdir -p $(OBJDIR) + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -rf $(OBJDIR) $(TARGET) diff --git a/programs/lib/libjpegwrite/libjpegwrite.a b/programs/lib/libjpegwrite/libjpegwrite.a new file mode 100644 index 0000000000000000000000000000000000000000..8bcb71e0b084fd08d191c5a1d4332321070aee6b GIT binary patch literal 134080 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 literal 0 HcmV?d00001 diff --git a/programs/lib/libjpegwrite/obj/stb_image_write_impl.o b/programs/lib/libjpegwrite/obj/stb_image_write_impl.o new file mode 100644 index 0000000000000000000000000000000000000000..5a1517af5842f3a6b372cbed34ad3ccc9e109886 GIT binary patch literal 133576 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

+2U+F6$zg7B7*3SAi5{eMv>qQD=6!2 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 +#include +#include + +/* Only enable JPEG writing. */ +#define STBI_WRITE_NO_STDIO + +/* Route allocations through libc (which uses MontaukOS heap). */ +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_FREE(p) free(p) +#define STBIW_REALLOC(p, newsz) realloc(p, newsz) +#define STBIW_MEMMOVE(d, s, n) memmove(d, s, n) + +#define STBIW_ASSERT(x) ((void)(x)) + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include diff --git a/programs/src/screenshot/Makefile b/programs/src/screenshot/Makefile new file mode 100644 index 0000000..30b1d61 --- /dev/null +++ b/programs/src/screenshot/Makefile @@ -0,0 +1,93 @@ +# Makefile for screenshot tool on MontaukOS +# Copyright (c) 2026 Daniel Hammer + +MAKEFLAGS += -rR +.SUFFIXES: + +# ---- Toolchain ---- + +TOOLCHAIN_PREFIX := $(shell cd ../../.. && pwd)/toolchain/local/bin/x86_64-elf- +ifneq ($(wildcard $(TOOLCHAIN_PREFIX)gcc),) + CXX := $(TOOLCHAIN_PREFIX)g++ +else + CXX := g++ +endif + +# ---- Paths ---- + +PROJECT_ROOT := $(shell cd ../../.. && pwd) +PROGRAMS := $(PROJECT_ROOT)/programs +JPEGWRITE_LIB := $(PROGRAMS)/lib/libjpegwrite +LIBC_LIB := $(PROGRAMS)/lib/libc +PROG_INC := $(PROGRAMS)/include +LINK_LD := $(PROGRAMS)/link.ld +BINDIR := $(PROGRAMS)/bin +OBJDIR := obj + +# ---- Compiler flags ---- + +CXXFLAGS := \ + -std=gnu++20 \ + -g -O2 -pipe \ + -Wall \ + -Wextra \ + -Wno-unused-parameter \ + -Wno-unused-function \ + -nostdinc \ + -ffreestanding \ + -fno-stack-protector \ + -fno-stack-check \ + -fno-PIC \ + -fno-rtti \ + -fno-exceptions \ + -ffunction-sections \ + -fdata-sections \ + -m64 \ + -march=x86-64 \ + -msse \ + -msse2 \ + -mno-red-zone \ + -mcmodel=small \ + -I $(PROG_INC) \ + -isystem $(PROG_INC)/libc \ + -isystem $(PROJECT_ROOT)/kernel/freestnd-c-hdrs/x86_64/include \ + -isystem $(PROJECT_ROOT)/kernel/freestnd-cxx-hdrs/x86_64/include + +# ---- Linker flags ---- + +LDFLAGS := \ + -nostdlib \ + -static \ + -Wl,--build-id=none \ + -Wl,--gc-sections \ + -Wl,-m,elf_x86_64 \ + -z max-page-size=0x1000 \ + -T $(LINK_LD) + +# ---- Libraries ---- + +LIBS := $(JPEGWRITE_LIB)/libjpegwrite.a $(LIBC_LIB)/liblibc.a + +# ---- Source files ---- + +SRCS := main.cpp +OBJS := $(addprefix $(OBJDIR)/,$(SRCS:.cpp=.o)) + +# ---- Target ---- + +TARGET := $(BINDIR)/apps/screenshot/screenshot.elf + +.PHONY: all clean + +all: $(TARGET) + +$(TARGET): $(OBJS) $(LIBS) $(LINK_LD) Makefile + mkdir -p $(BINDIR)/apps/screenshot + $(CXX) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@ + +$(OBJDIR)/%.o: %.cpp Makefile + mkdir -p $(OBJDIR) + $(CXX) $(CXXFLAGS) -c $< -o $@ + +clean: + rm -rf $(OBJDIR) $(TARGET) diff --git a/programs/src/screenshot/main.cpp b/programs/src/screenshot/main.cpp new file mode 100644 index 0000000..052e232 --- /dev/null +++ b/programs/src/screenshot/main.cpp @@ -0,0 +1,168 @@ +/* + * main.cpp + * MontaukOS Screenshot Tool + * Captures the screen framebuffer and saves as JPEG to the user's Pictures directory. + * Copyright (c) 2026 Daniel Hammer + */ + +#include +#include +#include +#include + +extern "C" { +#include +#include +#include + +#define STBI_WRITE_NO_STDIO +#include +} + +// ============================================================================ +// JPEG write callback - accumulates encoded bytes into a resizable buffer +// ============================================================================ + +struct JpegBuffer { + uint8_t* data; + uint64_t size; + uint64_t capacity; +}; + +static void jpeg_write_callback(void* context, void* data, int size) { + JpegBuffer* buf = (JpegBuffer*)context; + if (size <= 0) return; + + uint64_t needed = buf->size + (uint64_t)size; + if (needed > buf->capacity) { + uint64_t new_cap = buf->capacity * 2; + if (new_cap < needed) new_cap = needed; + uint8_t* new_data = (uint8_t*)montauk::realloc(buf->data, new_cap); + if (!new_data) return; + buf->data = new_data; + buf->capacity = new_cap; + } + montauk::memcpy(buf->data + buf->size, data, size); + buf->size += (uint64_t)size; +} + +// ============================================================================ +// Entry point +// ============================================================================ + +extern "C" void _start() { + // Get framebuffer info before doing anything else + Montauk::FbInfo fb; + montauk::fb_info(&fb); + + int width = (int)fb.width; + int height = (int)fb.height; + int pitch = (int)fb.pitch; + + if (width <= 0 || height <= 0) { + montauk::print("screenshot: no framebuffer available\n"); + montauk::exit(1); + } + + // Map the hardware framebuffer (read-only access to screen pixels) + uint32_t* hw_fb = (uint32_t*)montauk::fb_map(); + if (!hw_fb) { + montauk::print("screenshot: failed to map framebuffer\n"); + montauk::exit(1); + } + + // Copy framebuffer and convert from BGRA (0xAARRGGBB) to packed RGB + uint64_t rgb_size = (uint64_t)width * height * 3; + uint8_t* rgb = (uint8_t*)montauk::malloc(rgb_size); + if (!rgb) { + montauk::print("screenshot: out of memory\n"); + montauk::exit(1); + } + + for (int y = 0; y < height; y++) { + uint32_t* src_row = (uint32_t*)((uint8_t*)hw_fb + y * pitch); + uint8_t* dst_row = rgb + y * width * 3; + for (int x = 0; x < width; x++) { + uint32_t px = src_row[x]; + dst_row[x * 3 + 0] = (px >> 16) & 0xFF; // R + dst_row[x * 3 + 1] = (px >> 8) & 0xFF; // G + dst_row[x * 3 + 2] = px & 0xFF; // B + } + } + + // Encode as JPEG (quality 100 - maximum quality) + JpegBuffer jpeg; + jpeg.data = (uint8_t*)montauk::malloc(256 * 1024); + jpeg.size = 0; + jpeg.capacity = 256 * 1024; + + if (!jpeg.data) { + montauk::mfree(rgb); + montauk::print("screenshot: out of memory for JPEG buffer\n"); + montauk::exit(1); + } + + int ok = stbi_write_jpg_to_func(jpeg_write_callback, &jpeg, + width, height, 3, rgb, 100); + montauk::mfree(rgb); + + if (!ok || jpeg.size == 0) { + montauk::mfree(jpeg.data); + montauk::print("screenshot: JPEG encoding failed\n"); + montauk::exit(1); + } + + // Build output path: 0:/users//Pictures/screenshot_YYYYMMDD_HHMMSS.jpg + char username[32] = {}; + { + auto doc = montauk::config::load("session"); + const char* name = doc.get_string("session.username", ""); + if (name[0] == '\0') { + doc.destroy(); + montauk::mfree(jpeg.data); + montauk::print("screenshot: no user session\n"); + montauk::exit(1); + } + montauk::strncpy(username, name, sizeof(username) - 1); + doc.destroy(); + } + + char home[128]; + snprintf(home, sizeof(home), "0:/users/%s", username); + + // Ensure Pictures directory exists + char pictures_dir[192]; + snprintf(pictures_dir, sizeof(pictures_dir), "%s/Pictures", home); + montauk::fmkdir(pictures_dir); + + // Build filename with timestamp + Montauk::DateTime dt; + montauk::gettime(&dt); + + char filepath[256]; + snprintf(filepath, sizeof(filepath), + "%s/screenshot_%04d%02d%02d_%02d%02d%02d.jpg", + pictures_dir, + (int)dt.Year, (int)dt.Month, (int)dt.Day, + (int)dt.Hour, (int)dt.Minute, (int)dt.Second); + + // Write JPEG file + int fd = montauk::fcreate(filepath); + if (fd < 0) { + montauk::mfree(jpeg.data); + montauk::print("screenshot: failed to create file\n"); + montauk::exit(1); + } + + montauk::fwrite(fd, jpeg.data, 0, jpeg.size); + montauk::close(fd); + montauk::mfree(jpeg.data); + + // Print confirmation + char msg[320]; + snprintf(msg, sizeof(msg), "Screenshot saved: %s (%dx%d, %llu bytes)\n", + filepath, width, height, (unsigned long long)jpeg.size); + montauk::print(msg); + + montauk::exit(0); +} diff --git a/programs/src/screenshot/manifest.toml b/programs/src/screenshot/manifest.toml new file mode 100644 index 0000000..3a533af --- /dev/null +++ b/programs/src/screenshot/manifest.toml @@ -0,0 +1,8 @@ +[app] +name = "Screenshot" +binary = "screenshot.elf" +icon = "screenshot.svg" + +[menu] +category = "System" +visible = true diff --git a/scripts/install_apps.sh b/scripts/install_apps.sh index fbb564e..7cc1a1f 100755 --- a/scripts/install_apps.sh +++ b/scripts/install_apps.sh @@ -31,6 +31,7 @@ APPS=( "bluetooth|apps/scalable/bluetooth.svg" "rpgdemo|apps/scalable/utilities-terminal.svg" "paint|apps/scalable/kolourpaint.svg" + "screenshot|apps/scalable/gnome-screenshot.svg" ) installed=0