From 7552d2fa2aa17eb9cdac77660aedd4378bbb4128 Mon Sep 17 00:00:00 2001 From: Alessandro Mauri Date: Sun, 12 Feb 2023 20:38:06 +0100 Subject: [PATCH] bru h --- text_rendering/font.c | 18 +- text_rendering/hash.c | 5 +- text_rendering/msdf_c/.gitignore | 3 + text_rendering/msdf_c/CMakeLists.txt | 8 + text_rendering/msdf_c/LICENSE | 22 + text_rendering/msdf_c/Readme.md | 27 + text_rendering/msdf_c/msdf.c | 4 + text_rendering/msdf_c/msdf.h | 1395 +++++++++++++ .../msdf_c/sample/fonts/Roboto-Regular.ttf | Bin 0 -> 168260 bytes .../msdf_c/sample/fonts/RobotoLicense.txt | 201 ++ text_rendering/msdf_c/sample/sample | Bin 0 -> 166152 bytes text_rendering/msdf_c/sample/sample.c | 210 ++ text_rendering/msdf_c/sample/sdf.png | Bin 0 -> 600 bytes .../msdf_c/sample/stb_image_write.h | 1724 +++++++++++++++++ text_rendering/msdf_c/sample/svpng.h | 110 ++ text_rendering/{ => msdf_c}/stb_truetype.h | 2 +- 16 files changed, 3719 insertions(+), 10 deletions(-) create mode 100644 text_rendering/msdf_c/.gitignore create mode 100644 text_rendering/msdf_c/CMakeLists.txt create mode 100644 text_rendering/msdf_c/LICENSE create mode 100644 text_rendering/msdf_c/Readme.md create mode 100644 text_rendering/msdf_c/msdf.c create mode 100644 text_rendering/msdf_c/msdf.h create mode 100644 text_rendering/msdf_c/sample/fonts/Roboto-Regular.ttf create mode 100644 text_rendering/msdf_c/sample/fonts/RobotoLicense.txt create mode 100755 text_rendering/msdf_c/sample/sample create mode 100644 text_rendering/msdf_c/sample/sample.c create mode 100644 text_rendering/msdf_c/sample/sdf.png create mode 100644 text_rendering/msdf_c/sample/stb_image_write.h create mode 100644 text_rendering/msdf_c/sample/svpng.h rename text_rendering/{ => msdf_c}/stb_truetype.h (99%) diff --git a/text_rendering/font.c b/text_rendering/font.c index 1d0acba..ecfba49 100644 --- a/text_rendering/font.c +++ b/text_rendering/font.c @@ -4,7 +4,8 @@ #include -#include "stb_truetype.h" +#include "msdf_c/stb_truetype.h" +#include "msdf_c/msdf.h" #include "util.h" #include "font.h" @@ -20,9 +21,8 @@ struct font_atlas { - unsigned int glyphs, width, height; + unsigned int glyphs; unsigned char *atlas; - unsigned int glyph_max_w, glyph_max_h; struct { stbtt_fontinfo info; @@ -33,6 +33,10 @@ struct font_atlas { }; +const unsigned int glyph_w = 32; +const unsigned int glyph_h = 32; + + // loads a font into memory, storing all the ASCII characters in the atlas int load_font(struct font_atlas *atlas, const char *path, int height) { @@ -49,10 +53,10 @@ int load_font(struct font_atlas *atlas, const char *path, int height) stbtt_GetFontBoundingBox(&(atlas->stb.info), &x0, &y0, &x1, &y1); baseline = atlas->stb.scale * -y0; - atlas->glyph_max_w = (atlas->stb.scale*x1) - (atlas->stb.scale*x0); - atlas->glyph_max_h = (baseline+atlas->stb.scale*y1) - (baseline+atlas->stb.scale*y0); - - atlas->atlas = emalloc(atlas->glyph_max_w*atlas->glyph_max_h*CACHE_SIZE); + //atlas->glyph_max_w = (atlas->stb.scale*x1) - (atlas->stb.scale*x0); + //atlas->glyph_max_h = (baseline+atlas->stb.scale*y1) - (baseline+atlas->stb.scale*y0); + //atlas->atlas = emalloc(atlas->glyph_max_w*atlas->glyph_max_h*CACHE_SIZE); + atlas->atlas return 0; } diff --git a/text_rendering/hash.c b/text_rendering/hash.c index cc2493d..7a554db 100644 --- a/text_rendering/hash.c +++ b/text_rendering/hash.c @@ -6,6 +6,7 @@ #include #include "hash.h" +#include "util.h" #define MAXSIZE 4096 @@ -27,7 +28,7 @@ struct hm_ref * hm_create(unsigned int size) size = 1<<__builtin_clz(size); // FIXME: check for intger overflow here - struct hm_ref *h = malloc(sizeof(struct hm_ref)+sizeof(struct hm_entry)*size); + struct hm_ref *h = emalloc(sizeof(struct hm_ref)+sizeof(struct hm_entry)*size); if (h) { h->items = 0; h->size = size; @@ -39,7 +40,7 @@ struct hm_ref * hm_create(unsigned int size) void hm_destroy(struct hm_ref *hm) { - free(hm); + efree(hm); } diff --git a/text_rendering/msdf_c/.gitignore b/text_rendering/msdf_c/.gitignore new file mode 100644 index 0000000..4d8154c --- /dev/null +++ b/text_rendering/msdf_c/.gitignore @@ -0,0 +1,3 @@ +build +.vscode +.DS_Store \ No newline at end of file diff --git a/text_rendering/msdf_c/CMakeLists.txt b/text_rendering/msdf_c/CMakeLists.txt new file mode 100644 index 0000000..6efc9f4 --- /dev/null +++ b/text_rendering/msdf_c/CMakeLists.txt @@ -0,0 +1,8 @@ +cmake_minimum_required(VERSION 3.19) +project(engine) + +add_definitions(-DSAMPLE_ROOT="${PROJECT_SOURCE_DIR}/sample") + +set(CMAKE_C_STANDARD 11) + +add_executable(msdf_sample sample/sample.c) \ No newline at end of file diff --git a/text_rendering/msdf_c/LICENSE b/text_rendering/msdf_c/LICENSE new file mode 100644 index 0000000..29cf0be --- /dev/null +++ b/text_rendering/msdf_c/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2023 Peter Jakobs +Copyright (c) 2018 exezin + +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. \ No newline at end of file diff --git a/text_rendering/msdf_c/Readme.md b/text_rendering/msdf_c/Readme.md new file mode 100644 index 0000000..6e4f858 --- /dev/null +++ b/text_rendering/msdf_c/Readme.md @@ -0,0 +1,27 @@ +# msdf_c 0.1 +A pure C99 multi-channel signed distance field generator. Handles MSDF bitmap +Generation from given ttf/otf font (outlines). +Single Header STB-style library + +--- + +[This library is my take on improving msdf-c with some fixes and improving its API](https://github.com/solenum/msdf-c) + +[Based on the C++ implementation by Viktor Chlumský.](https://github.com/Chlumsky/msdfgen) + +~~~ +// example fragment shader +// scale is render_width/glyph_width +// render_width being the width of each rendered glyph +float median(float r, float g, float b) { + return max(min(r, g), min(max(r, g), b)); +} + +void main() +{ + vec3 sample = texture(u_texture, uv).rgb; + float dist = scale * (median(sample.r, sample.g, sample.b) - 0.5); + float o = clamp(dist + 0.5, 0.0, 1.0); + color = vec4(vec3(1.0), o); +} +~~~ diff --git a/text_rendering/msdf_c/msdf.c b/text_rendering/msdf_c/msdf.c new file mode 100644 index 0000000..3ca1194 --- /dev/null +++ b/text_rendering/msdf_c/msdf.c @@ -0,0 +1,4 @@ +#define STB_TRUETYPE_IMPLEMENTATION +#include "stb_truetype.h" +#define MSDF_IMPLEMENTATION +#include "msdf.h" diff --git a/text_rendering/msdf_c/msdf.h b/text_rendering/msdf_c/msdf.h new file mode 100644 index 0000000..e303e23 --- /dev/null +++ b/text_rendering/msdf_c/msdf.h @@ -0,0 +1,1395 @@ +/* msdf + Handles multi-channel signed distance field bitmap + generation from given ttf (stb_truetype.h) font. + https://github.com/exezin/msdf-c + Depends on stb_truetype.h to load the ttf file. + This is in an unstable state, ymmv. + Based on the C++ implementation by Viktor Chlumský. + https://github.com/Chlumsky/msdfgen +*/ + +#ifndef MSDF_H +#define MSDF_H + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + int glyphIdx; + int left_bearing; + int advance; + int ix0, ix1; + int iy0, iy1; +} ex_metrics_t; + +typedef struct msdf_Result { + int glyphIdx; + int left_bearing; + int advance; + float* rgb; + int width; + int height; + int yOffset; +} msdf_Result; + +typedef struct msdf_AllocCtx { + void* (*alloc)(size_t size, void* ctx); + // free is optional and will not be called if it is null (useful for area allocators that free everything at once) + void (*free)(void* ptr, void* ctx); + void* ctx; +} msdf_AllocCtx; + +/* + Generates a bitmap from the specified glyph index of a stbtt font + + Returned result is 1 for success or 0 in case of an error + */ +int msdf_genGlyph(msdf_Result* result, stbtt_fontinfo *font, int stbttGlyphIndex, uint32_t borderWidth, float scale, float range, msdf_AllocCtx* alloc); + +#ifdef __cplusplus +} +#endif + +#ifdef MSDF_IMPLEMENTATION +// pixel at (x, y) in bitmap (arr) +#define msdf_pixelAt(x, y, w, arr) ((msdf_Vec3){arr[(3 * (((y)*w) + x))], arr[(3 * (((y)*w) + x)) + 1], arr[(3 * (((y)*w) + x)) + 2]}) + +#define msdf_max(x, y) (((x) > (y)) ? (x) : (y)) +#define msdf_min(x, y) (((x) < (y)) ? (x) : (y)) + +#define MSDF_INF -1e24 +#define MSDF_EDGE_THRESHOLD 0.02 + +#ifndef MSDF_PI +#define MSDF_PI 3.14159265358979323846 +#endif + +typedef float msdf_Vec2[2]; +typedef float msdf_Vec3[3]; + +typedef struct +{ + double dist; + double d; +} msdf_signedDistance; + +// the possible types: +// STBTT_vmove = start of a contour +// STBTT_vline = linear segment +// STBTT_vcurve = quadratic segment +// STBTT_vcubic = cubic segment +typedef struct +{ + int color; + msdf_Vec2 p[4]; + int type; +} msdf_EdgeSegment; + +// defines what color channel an edge belongs to +typedef enum +{ + msdf_edgeColor_black = 0, + msdf_edgeColor_red = 1, + msdf_edgeColor_green = 2, + msdf_edgeColor_yellow = 3, + msdf_edgeColor_blue = 4, + msdf_edgeColor_magenta = 5, + msdf_edgeColor_cyan = 6, + msdf_edgeColor_white = 7 +} msdf_edgeColor; + +static double msdf_median(double a, double b, double c) +{ + return msdf_max(msdf_min(a, b), msdf_min(msdf_max(a, b), c)); +} + +static int msdf_nonZeroSign(double n) +{ + return 2 * (n > 0) - 1; +} + +static double msdf_cross(msdf_Vec2 a, msdf_Vec2 b) +{ + return a[0] * b[1] - a[1] * b[0]; +} + +static void msdf_v2Scale(msdf_Vec2 r, msdf_Vec2 const v, float const s) +{ + int i; + for (i = 0; i < 2; ++i) + r[i] = v[i] * s; +} + +static float msdf_v2MulInner(msdf_Vec2 const a, msdf_Vec2 const b) +{ + float p = 0.; + int i; + for (i = 0; i < 2; ++i) + p += b[i] * a[i]; + return p; +} + +static float msdf_v2Leng(msdf_Vec2 const v) +{ + return sqrtf(msdf_v2MulInner(v, v)); +} + +static void msdf_v2Norm(msdf_Vec2 r, msdf_Vec2 const v) +{ + float k = 1.0 / msdf_v2Leng(v); + msdf_v2Scale(r, v, k); +} + +static void msdf_v2Sub(msdf_Vec2 r, msdf_Vec2 const a, msdf_Vec2 const b) +{ + int i; + for (i = 0; i < 2; ++i) + r[i] = a[i] - b[i]; +} + +int msdf_solveQuadratic(double x[2], double a, double b, double c) +{ + if (fabs(a) < 1e-14) + { + if (fabs(b) < 1e-14) + { + if (c == 0) + return -1; + return 0; + } + x[0] = -c / b; + return 1; + } + + double dscr = b * b - 4 * a * c; + if (dscr > 0) + { + dscr = sqrt(dscr); + x[0] = (-b + dscr) / (2 * a); + x[1] = (-b - dscr) / (2 * a); + return 2; + } + else if (dscr == 0) + { + x[0] = -b / (2 * a); + return 1; + } + else + { + return 0; + } +} + +int msdf_solveCubicNormed(double *x, double a, double b, double c) +{ + double a2 = a * a; + double q = (a2 - 3 * b) / 9; + double r = (a * (2 * a2 - 9 * b) + 27 * c) / 54; + double r2 = r * r; + double q3 = q * q * q; + double A, B; + if (r2 < q3) + { + double t = r / sqrt(q3); + if (t < -1) + t = -1; + if (t > 1) + t = 1; + t = acos(t); + a /= 3; + q = -2 * sqrt(q); + x[0] = q * cos(t / 3) - a; + x[1] = q * cos((t + 2 * MSDF_PI) / 3) - a; + x[2] = q * cos((t - 2 * MSDF_PI) / 3) - a; + return 3; + } + else + { + A = -pow(fabs(r) + sqrt(r2 - q3), 1 / 3.); + if (r < 0) + A = -A; + B = A == 0 ? 0 : q / A; + a /= 3; + x[0] = (A + B) - a; + x[1] = -0.5 * (A + B) - a; + x[2] = 0.5 * sqrt(3.) * (A - B); + if (fabs(x[2]) < 1e-14) + return 2; + return 1; + } +} + +int msdf_solveCubic(double x[3], double a, double b, double c, double d) +{ + if (fabs(a) < 1e-14) + return msdf_solveQuadratic(x, b, c, d); + + return msdf_solveCubicNormed(x, b / a, c / a, d / a); +} + +void msdf_getOrtho(msdf_Vec2 r, msdf_Vec2 const v, int polarity, int allow_zero) +{ + double len = msdf_v2Leng(v); + + if (len == 0) + { + if (polarity) + { + r[0] = 0; + r[1] = !allow_zero; + } + else + { + r[0] = 0; + r[1] = -!allow_zero; + } + return; + } + + if (polarity) + { + r[0] = -v[1] / len; + r[1] = v[0] / len; + } + else + { + r[0] = v[1] / len; + r[1] = -v[0] / len; + } +} + +int msdf_pixelClash(const msdf_Vec3 a, const msdf_Vec3 b, double threshold) +{ + int aIn = (a[0] > .5f) + (a[1] > .5f) + (a[2] > .5f) >= 2; + int bIn = (b[0] > .5f) + (b[1] > .5f) + (b[2] > .5f) >= 2; + if (aIn != bIn) + return 0; + if ((a[0] > .5f && a[1] > .5f && a[2] > .5f) || (a[0] < .5f && a[1] < .5f && a[2] < .5f) || (b[0] > .5f && b[1] > .5f && b[2] > .5f) || (b[0] < .5f && b[1] < .5f && b[2] < .5f)) + return 0; + float aa, ab, ba, bb, ac, bc; + if ((a[0] > .5f) != (b[0] > .5f) && (a[0] < .5f) != (b[0] < .5f)) + { + aa = a[0], ba = b[0]; + if ((a[1] > .5f) != (b[1] > .5f) && (a[1] < .5f) != (b[1] < .5f)) + { + ab = a[1], bb = b[1]; + ac = a[2], bc = b[2]; + } + else if ((a[2] > .5f) != (b[2] > .5f) && (a[2] < .5f) != (b[2] < .5f)) + { + ab = a[2], bb = b[2]; + ac = a[1], bc = b[1]; + } + else + { + return 0; + } + } + else if ((a[1] > .5f) != (b[1] > .5f) && (a[1] < .5f) != (b[1] < .5f) && (a[2] > .5f) != (b[2] > .5f) && (a[2] < .5f) != (b[2] < .5f)) + { + aa = a[1], ba = b[1]; + ab = a[2], bb = b[2]; + ac = a[0], bc = b[0]; + } + else + { + return 0; + } + return (fabsf(aa - ba) >= threshold) && (fabsf(ab - bb) >= threshold) && fabsf(ac - .5f) >= fabsf(bc - .5f); +} + +void msdf_mix(msdf_Vec2 r, msdf_Vec2 a, msdf_Vec2 b, double weight) +{ + r[0] = (1 - weight) * a[0] + weight * b[0]; + r[1] = (1 - weight) * a[1] + weight * b[1]; +} + +void msdf_linearDirection(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + r[0] = e->p[1][0] - e->p[0][0]; + r[1] = e->p[1][1] - e->p[0][1]; +} + +void msdf_quadraticDirection(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + msdf_Vec2 a, b; + msdf_v2Sub(a, e->p[1], e->p[0]); + msdf_v2Sub(b, e->p[2], e->p[1]); + msdf_mix(r, a, b, param); +} + +void msdf_cubicDirection(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + msdf_Vec2 a, b, c, d, t; + msdf_v2Sub(a, e->p[1], e->p[0]); + msdf_v2Sub(b, e->p[2], e->p[1]); + msdf_mix(c, a, b, param); + msdf_v2Sub(a, e->p[3], e->p[2]); + msdf_mix(d, b, a, param); + msdf_mix(t, c, d, param); + + if (!t[0] && !t[1]) + { + if (param == 0) + { + r[0] = e->p[2][0] - e->p[0][0]; + r[1] = e->p[2][1] - e->p[0][1]; + return; + } + if (param == 1) + { + r[0] = e->p[3][0] - e->p[1][0]; + r[1] = e->p[3][1] - e->p[1][1]; + return; + } + } + + r[0] = t[0]; + r[1] = t[1]; +} + +void msdf_direction(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + switch (e->type) + { + case STBTT_vline: + { + msdf_linearDirection(r, e, param); + break; + } + case STBTT_vcurve: + { + msdf_quadraticDirection(r, e, param); + break; + } + case STBTT_vcubic: + { + msdf_cubicDirection(r, e, param); + break; + } + } +} + +void msdf_linearPoint(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + msdf_mix(r, e->p[0], e->p[1], param); +} + +void msdf_quadraticPoint(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + msdf_Vec2 a, b; + msdf_mix(a, e->p[0], e->p[1], param); + msdf_mix(b, e->p[1], e->p[2], param); + msdf_mix(r, a, b, param); +} + +void msdf_cubicPoint(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + msdf_Vec2 p12, a, b, c, d; + msdf_mix(p12, e->p[1], e->p[2], param); + + msdf_mix(a, e->p[0], e->p[1], param); + msdf_mix(b, a, p12, param); + + msdf_mix(c, e->p[2], e->p[3], param); + msdf_mix(d, p12, c, param); + + msdf_mix(r, b, d, param); +} + +void msdf_point(msdf_Vec2 r, msdf_EdgeSegment *e, double param) +{ + switch (e->type) + { + case STBTT_vline: + { + msdf_linearPoint(r, e, param); + break; + } + case STBTT_vcurve: + { + msdf_quadraticPoint(r, e, param); + break; + } + case STBTT_vcubic: + { + msdf_cubicPoint(r, e, param); + break; + } + } +} + +// linear edge signed distance +msdf_signedDistance msdf_linearDist(msdf_EdgeSegment *e, msdf_Vec2 origin, double *param) +{ + msdf_Vec2 aq, ab, eq; + msdf_v2Sub(aq, origin, e->p[0]); + msdf_v2Sub(ab, e->p[1], e->p[0]); + *param = msdf_v2MulInner(aq, ab) / msdf_v2MulInner(ab, ab); + msdf_v2Sub(eq, e->p[*param > .5], origin); + + double endpoint_distance = msdf_v2Leng(eq); + if (*param > 0 && *param < 1) + { + msdf_Vec2 ab_ortho; + msdf_getOrtho(ab_ortho, ab, 0, 0); + double ortho_dist = msdf_v2MulInner(ab_ortho, aq); + if (fabs(ortho_dist) < endpoint_distance) + return (msdf_signedDistance){ortho_dist, 0}; + } + + msdf_v2Norm(ab, ab); + msdf_v2Norm(eq, eq); + double dist = msdf_nonZeroSign(msdf_cross(aq, ab)) * endpoint_distance; + double d = fabs(msdf_v2MulInner(ab, eq)); + return (msdf_signedDistance){dist, d}; +} + +// quadratic edge signed distance +msdf_signedDistance msdf_quadraticDist(msdf_EdgeSegment *e, msdf_Vec2 origin, double *param) +{ + msdf_Vec2 qa, ab, br; + msdf_v2Sub(qa, e->p[0], origin); + msdf_v2Sub(ab, e->p[1], e->p[0]); + br[0] = e->p[0][0] + e->p[2][0] - e->p[1][0] - e->p[1][0]; + br[1] = e->p[0][1] + e->p[2][1] - e->p[1][1] - e->p[1][1]; + + double a = msdf_v2MulInner(br, br); + double b = 3 * msdf_v2MulInner(ab, br); + double c = 2 * msdf_v2MulInner(ab, ab) + msdf_v2MulInner(qa, br); + double d = msdf_v2MulInner(qa, ab); + double t[3]; + int solutions = msdf_solveCubic(t, a, b, c, d); + + // distance from a + double min_distance = msdf_nonZeroSign(msdf_cross(ab, qa)) * msdf_v2Leng(qa); + *param = -msdf_v2MulInner(qa, ab) / msdf_v2MulInner(ab, ab); + { + msdf_Vec2 a, b; + msdf_v2Sub(a, e->p[2], e->p[1]); + msdf_v2Sub(b, e->p[2], origin); + + // distance from b + double distance = msdf_nonZeroSign(msdf_cross(a, b)) * msdf_v2Leng(b); + if (fabs(distance) < fabs(min_distance)) + { + min_distance = distance; + + msdf_v2Sub(a, origin, e->p[1]); + msdf_v2Sub(b, e->p[2], e->p[1]); + *param = msdf_v2MulInner(a, b) / msdf_v2MulInner(b, b); + } + } + + for (int i = 0; i < solutions; ++i) + { + if (t[i] > 0 && t[i] < 1) + { + // end_point = p[0]+2*t[i]*ab+t[i]*t[i]*br; + msdf_Vec2 end_point, a, b; + end_point[0] = e->p[0][0] + 2 * t[i] * ab[0] + t[i] * t[i] * br[0]; + end_point[1] = e->p[0][1] + 2 * t[i] * ab[1] + t[i] * t[i] * br[1]; + + msdf_v2Sub(a, e->p[2], e->p[0]); + msdf_v2Sub(b, end_point, origin); + double distance = msdf_nonZeroSign(msdf_cross(a, b)) * msdf_v2Leng(b); + if (fabs(distance) <= fabs(min_distance)) + { + min_distance = distance; + *param = t[i]; + } + } + } + + if (*param >= 0 && *param <= 1) + return (msdf_signedDistance){min_distance, 0}; + + msdf_Vec2 aa, bb; + msdf_v2Norm(ab, ab); + msdf_v2Norm(qa, qa); + msdf_v2Sub(aa, e->p[2], e->p[1]); + msdf_v2Norm(aa, aa); + msdf_v2Sub(bb, e->p[2], origin); + msdf_v2Norm(bb, bb); + + if (*param < .5) + return (msdf_signedDistance){min_distance, fabs(msdf_v2MulInner(ab, qa))}; + else + return (msdf_signedDistance){min_distance, fabs(msdf_v2MulInner(aa, bb))}; +} + +// cubic edge signed distance +msdf_signedDistance msdf_cubicDist(msdf_EdgeSegment *e, msdf_Vec2 origin, double *param) +{ + msdf_Vec2 qa, ab, br, as; + msdf_v2Sub(qa, e->p[0], origin); + msdf_v2Sub(ab, e->p[1], e->p[0]); + br[0] = e->p[2][0] - e->p[1][0] - ab[0]; + br[1] = e->p[2][1] - e->p[1][1] - ab[1]; + as[0] = (e->p[3][0] - e->p[2][0]) - (e->p[2][0] - e->p[1][0]) - br[0]; + as[1] = (e->p[3][1] - e->p[2][1]) - (e->p[2][1] - e->p[1][1]) - br[1]; + + msdf_Vec2 ep_dir; + msdf_direction(ep_dir, e, 0); + + // distance from a + double min_distance = msdf_nonZeroSign(msdf_cross(ep_dir, qa)) * msdf_v2Leng(qa); + *param = -msdf_v2MulInner(qa, ep_dir) / msdf_v2MulInner(ep_dir, ep_dir); + { + msdf_Vec2 a; + msdf_v2Sub(a, e->p[3], origin); + + msdf_direction(ep_dir, e, 1); + // distance from b + double distance = msdf_nonZeroSign(msdf_cross(ep_dir, a)) * msdf_v2Leng(a); + if (fabs(distance) < fabs(min_distance)) + { + min_distance = distance; + + a[0] = origin[0] + ep_dir[0] - e->p[3][0]; + a[1] = origin[1] + ep_dir[1] - e->p[3][1]; + *param = msdf_v2MulInner(a, ep_dir) / msdf_v2MulInner(ep_dir, ep_dir); + } + } + + const int search_starts = 4; + for (int i = 0; i <= search_starts; ++i) + { + double t = (double)i / search_starts; + for (int step = 0;; ++step) + { + msdf_Vec2 qpt; + msdf_point(qpt, e, t); + msdf_v2Sub(qpt, qpt, origin); + msdf_Vec2 d; + msdf_direction(d, e, t); + double distance = msdf_nonZeroSign(msdf_cross(d, qpt)) * msdf_v2Leng(qpt); + if (fabs(distance) < fabs(min_distance)) + { + min_distance = distance; + *param = t; + } + if (step == search_starts) + break; + + msdf_Vec2 d1, d2; + d1[0] = 3 * as[0] * t * t + 6 * br[0] * t + 3 * ab[0]; + d1[1] = 3 * as[1] * t * t + 6 * br[1] * t + 3 * ab[1]; + d2[0] = 6 * as[0] * t + 6 * br[0]; + d2[1] = 6 * as[1] * t + 6 * br[1]; + + t -= msdf_v2MulInner(qpt, d1) / (msdf_v2MulInner(d1, d1) + msdf_v2MulInner(qpt, d2)); + if (t < 0 || t > 1) + break; + } + } + + if (*param >= 0 && *param <= 1) + return (msdf_signedDistance){min_distance, 0}; + + msdf_Vec2 d0, d1; + msdf_direction(d0, e, 0); + msdf_direction(d1, e, 1); + msdf_v2Norm(d0, d0); + msdf_v2Norm(d1, d1); + msdf_v2Norm(qa, qa); + msdf_Vec2 a; + msdf_v2Sub(a, e->p[3], origin); + msdf_v2Norm(a, a); + + if (*param < .5) + return (msdf_signedDistance){min_distance, fabs(msdf_v2MulInner(d0, qa))}; + else + return (msdf_signedDistance){min_distance, fabs(msdf_v2MulInner(d1, a))}; +} + +void msdf_distToPseudo(msdf_signedDistance *distance, msdf_Vec2 origin, double param, msdf_EdgeSegment *e) { + if (param < 0) { + msdf_Vec2 dir, p; + msdf_direction(dir, e, 0); + msdf_v2Norm(dir, dir); + msdf_Vec2 aq = {origin[0], origin[1]}; + msdf_point(p, e, 0); + msdf_v2Sub(aq, origin, p); + double ts = msdf_v2MulInner(aq, dir); + if (ts < 0) { + double pseudo_dist = msdf_cross(aq, dir); + if (fabs(pseudo_dist) <= fabs(distance->dist)) { + distance->dist = pseudo_dist; + distance->d = 0; + } + } + } else if (param > 1) { + msdf_Vec2 dir, p; + msdf_direction(dir, e, 1); + msdf_v2Norm(dir, dir); + msdf_Vec2 bq = {origin[0], origin[1]}; + msdf_point(p, e, 1); + msdf_v2Sub(bq, origin, p); + double ts = msdf_v2MulInner(bq, dir); + if (ts > 0) { + double pseudo_dist = msdf_cross(bq, dir); + if (fabs(pseudo_dist) <= fabs(distance->dist)) { + distance->dist = pseudo_dist; + distance->d = 0; + } + } + } +} + +int msdf_signedCompare(msdf_signedDistance a, msdf_signedDistance b) { + return fabs(a.dist) < fabs(b.dist) || (fabs(a.dist) == fabs(b.dist) && a.d < b.d); +} + +int msdf_isCorner(msdf_Vec2 a, msdf_Vec2 b, double threshold) { + return msdf_v2MulInner(a, b) <= 0 || fabs(msdf_cross(a, b)) > threshold; +} + +void msdf_switchColor(msdf_edgeColor *color, unsigned long long *seed, msdf_edgeColor banned) +{ + msdf_edgeColor combined = *color & banned; + if (combined == msdf_edgeColor_red || combined == msdf_edgeColor_green || combined == msdf_edgeColor_blue) { + *color = (msdf_edgeColor)(combined ^ msdf_edgeColor_white); + return; + } + + if (*color == msdf_edgeColor_black || *color == msdf_edgeColor_white) { + static const msdf_edgeColor start[3] = {msdf_edgeColor_cyan, msdf_edgeColor_magenta, msdf_edgeColor_yellow}; + *color = start[*seed & 3]; + *seed /= 3; + return; + } + + int shifted = *color << (1 + (*seed & 1)); + *color = (msdf_edgeColor)((shifted | shifted >> 3) & msdf_edgeColor_white); + *seed >>= 1; +} + +void msdf_linearSplit(msdf_EdgeSegment *e, msdf_EdgeSegment *p1, msdf_EdgeSegment *p2, msdf_EdgeSegment *p3) +{ + msdf_Vec2 p; + + msdf_point(p, e, 1 / 3.0); + memcpy(&p1->p[0], e->p[0], sizeof(msdf_Vec2)); + memcpy(&p1->p[1], p, sizeof(msdf_Vec2)); + p1->color = e->color; + + msdf_point(p, e, 1 / 3.0); + memcpy(&p2->p[0], p, sizeof(msdf_Vec2)); + msdf_point(p, e, 2 / 3.0); + memcpy(&p2->p[1], p, sizeof(msdf_Vec2)); + p2->color = e->color; + + msdf_point(p, e, 2 / 3.0); + memcpy(&p3->p[0], p, sizeof(msdf_Vec2)); + msdf_point(p, e, 2 / 3.0); + memcpy(&p3->p[1], e->p[1], sizeof(msdf_Vec2)); + p3->color = e->color; +} + +void msdf_quadraticSplit(msdf_EdgeSegment *e, msdf_EdgeSegment *p1, msdf_EdgeSegment *p2, msdf_EdgeSegment *p3) +{ + msdf_Vec2 p, a, b; + + memcpy(&p1->p[0], e->p[0], sizeof(msdf_Vec2)); + msdf_mix(p, e->p[0], e->p[1], 1 / 3.0); + memcpy(&p1->p[1], p, sizeof(msdf_Vec2)); + msdf_point(p, e, 1 / 3.0); + memcpy(&p1->p[2], p, sizeof(msdf_Vec2)); + p1->color = e->color; + + msdf_point(p, e, 1 / 3.0); + memcpy(&p2->p[0], p, sizeof(msdf_Vec2)); + msdf_mix(a, e->p[0], e->p[1], 5 / 9.0); + msdf_mix(b, e->p[1], e->p[2], 4 / 9.0); + msdf_mix(p, a, b, 0.5); + memcpy(&p2->p[1], p, sizeof(msdf_Vec2)); + msdf_point(p, e, 2 / 3.0); + memcpy(&p2->p[2], p, sizeof(msdf_Vec2)); + p2->color = e->color; + + msdf_point(p, e, 2 / 3.0); + memcpy(&p3->p[0], p, sizeof(msdf_Vec2)); + msdf_mix(p, e->p[1], e->p[2], 2 / 3.0); + memcpy(&p3->p[1], p, sizeof(msdf_Vec2)); + memcpy(&p3->p[2], e->p[2], sizeof(msdf_Vec2)); + p3->color = e->color; +} + +void msdf_cubicSplit(msdf_EdgeSegment *e, msdf_EdgeSegment *p1, msdf_EdgeSegment *p2, msdf_EdgeSegment *p3) +{ + msdf_Vec2 p, a, b, c, d; + + memcpy(&p1->p[0], e->p[0], sizeof(msdf_Vec2)); // p1 0 + if (e->p[0] == e->p[1]) { + memcpy(&p1->p[1], e->p[0], sizeof(msdf_Vec2)); // ? p1 1 + } else { + msdf_mix(p, e->p[0], e->p[1], 1 / 3.0); + memcpy(&p1->p[1], p, sizeof(msdf_Vec2)); // ? p1 1 + } + msdf_mix(a, e->p[0], e->p[1], 1 / 3.0); + msdf_mix(b, e->p[1], e->p[2], 1 / 3.0); + msdf_mix(p, a, b, 1 / 3.0); + memcpy(&p1->p[2], p, sizeof(msdf_Vec2)); // p1 2 + msdf_point(p, e, 1 / 3.0); + memcpy(&p1->p[3], p, sizeof(msdf_Vec2)); // p1 3 + p1->color = e->color; + + msdf_point(p, e, 1 / 3.0); + memcpy(&p2->p[0], p, sizeof(msdf_Vec2)); // p2 0 + msdf_mix(a, e->p[0], e->p[1], 1 / 3.0); + msdf_mix(b, e->p[1], e->p[2], 1 / 3.0); + msdf_mix(c, a, b, 1 / 3.0); + msdf_mix(a, e->p[1], e->p[2], 1 / 3.0); + msdf_mix(b, e->p[2], e->p[3], 1 / 3.0); + msdf_mix(d, a, b, 1 / 3.0); + msdf_mix(p, c, d, 2 / 3.0); + memcpy(&p2->p[1], p, sizeof(msdf_Vec2)); // p2 1 + msdf_mix(a, e->p[0], e->p[1], 2 / 3.0); + msdf_mix(b, e->p[1], e->p[2], 2 / 3.0); + msdf_mix(c, a, b, 2 / 3.0); + msdf_mix(a, e->p[1], e->p[2], 2 / 3.0); + msdf_mix(b, e->p[2], e->p[3], 2 / 3.0); + msdf_mix(d, a, b, 2 / 3.0); + msdf_mix(p, c, d, 1 / 3.0); + memcpy(&p2->p[2], p, sizeof(msdf_Vec2)); // p2 2 + msdf_point(p, e, 2 / 3.0); + memcpy(&p2->p[3], p, sizeof(msdf_Vec2)); // p2 3 + p2->color = e->color; + + msdf_point(p, e, 2 / 3.0); + memcpy(&p3->p[0], p, sizeof(msdf_Vec2)); // p3 0 + + msdf_mix(a, e->p[1], e->p[2], 2 / 3.0); + msdf_mix(b, e->p[2], e->p[3], 2 / 3.0); + msdf_mix(p, a, b, 2 / 3.0); + memcpy(&p3->p[1], p, sizeof(msdf_Vec2)); // p3 1 + + if (e->p[2] == e->p[3]) { + memcpy(&p3->p[2], e->p[3], sizeof(msdf_Vec2)); // ? p3 2 + } else { + msdf_mix(p, e->p[2], e->p[3], 2 / 3.0); + memcpy(&p3->p[2], p, sizeof(msdf_Vec2)); // ? p3 2 + } + + memcpy(&p3->p[3], e->p[3], sizeof(msdf_Vec2)); // p3 3 +} + +void msdf_edgeSplit(msdf_EdgeSegment *e, msdf_EdgeSegment *p1, msdf_EdgeSegment *p2, msdf_EdgeSegment *p3) +{ + switch (e->type) { + case STBTT_vline: { + msdf_linearSplit(e, p1, p2, p3); + break; + } + case STBTT_vcurve: { + msdf_quadraticSplit(e, p1, p2, p3); + break; + } + case STBTT_vcubic: { + msdf_cubicSplit(e, p1, p2, p3); + break; + } + } +} + +double msdf_shoelace(const msdf_Vec2 a, const msdf_Vec2 b) +{ + return (b[0] - a[0]) * (a[1] + b[1]); +} + + +void* msdf__alloc(size_t size, void* ctx) { + return malloc(size); +} +void msdf__free(void* ptr, void* ctx) { + free(ptr); +} + +int msdf_genGlyph(msdf_Result* result, stbtt_fontinfo *font, int stbttGlyphIndex, uint32_t borderWidth, float scale, float range, msdf_AllocCtx* alloc) { + msdf_AllocCtx allocCtx; + + if (alloc) { + allocCtx = *alloc; + } else { + allocCtx.alloc = msdf__alloc; + allocCtx.free = msdf__free; + allocCtx.ctx = NULL; + } + + //char f = c; + // Funit to pixel scale + //float scale = stbtt_ScaleForMappingEmToPixels(font, h); + int glyphIdx = stbttGlyphIndex; + // get glyph bounding box (scaled later) + int ix0, iy0, ix1, iy1; + float xoff = .0, yoff = .0; + stbtt_GetGlyphBox(font, glyphIdx, &ix0, &iy0, &ix1, &iy1); + + float glyphWidth = ix1 - ix0; + float glyphHeight = iy1 - iy0; + float borderWidthF32 = borderWidth; + float wF32 = ceilf(glyphWidth * scale); + float hF32 = ceilf(glyphHeight * scale); + wF32 += 2.f * borderWidth; + hF32 += 2.f * borderWidth; + int w = wF32; + int h = hF32; + + float* bitmap = (float*) allocCtx.alloc(w * h * 3 * sizeof(float), allocCtx.ctx); + memset(bitmap, 0x0, w * h * 3 * sizeof(float)); + + // em scale + //scale = stbtt_ScaleForMappingEmToPixels(font, h); + + //if (autofit) + //{ + + // calculate new height + //float newh = h + (h - (iy1 - iy0) * scale) - 4; + + // calculate new scale + // see 'stbtt_ScaleForMappingEmToPixels' in stb_truetype.h + //uint8_t *p = font->data + font->head + 18; + //int unitsPerEm = p[0] * 256 + p[1]; + //scale = ((float)h) / ((float)unitsPerEm); + + // make sure we are centered + //xoff = .0; + //yoff = .0; + //} + + // get left offset and advance + //int left_bearing, advance; + //stbtt_GetGlyphHMetrics(font, glyphIdx, &advance, &left_bearing); + //left_bearing *= scale; + + int32_t glyphOrgX = ix0 * scale; + int32_t glyphOrgY = iy0 * scale; + + int32_t borderWidthX = borderWidth; + int32_t borderWidthY = borderWidth; + + // org 8,8 + // - bord 4,4 + // erg: 4,4 + + // calculate offset for centering glyph on bitmap + + //glyphOrgX >= 2 ? (glyphOrgX) : (); + int32_t translateX = (glyphOrgX - borderWidth);//borderWidth + ((w / 2) - ((ix1 - ix0) * scale) / 2 - leftBearingScaled); + int32_t translateY = (glyphOrgY - borderWidth);//borderWidth + ((h / 2) - ((iy1 - iy0) * scale) / 2 - ((float) iy0) * scale); + //translateY = 8; + // set the glyph metrics + // (pre-scale them) + + #if 0 + if (metrics) + { + metrics->left_bearing = left_bearing; + metrics->advance = advance * scale; + metrics->ix0 = ix0 * scale; + metrics->ix1 = ix1 * scale; + metrics->iy0 = iy0 * scale; + metrics->iy1 = iy1 * scale; + metrics->glyphIdx = glyphIdx; + } + #endif + + stbtt_vertex *verts; + int num_verts = stbtt_GetGlyphShape(font, glyphIdx, &verts); + + // figure out how many contours exist + int contour_count = 0; + for (int i = 0; i < num_verts; i++) { + if (verts[i].type == STBTT_vmove) { + contour_count++; + } + } + + if (contour_count == 0) { + return 0; + } + + // determin what vertices belong to what contours + typedef struct { + size_t start, end; + } msdf_Indices; + msdf_Indices *contours = allocCtx.alloc(sizeof(msdf_Indices) * contour_count, allocCtx.ctx); + int j = 0; + for (int i = 0; i <= num_verts; i++) { + if (verts[i].type == STBTT_vmove) { + if (i > 0) { + contours[j].end = i; + j++; + } + + contours[j].start = i; + } else if (i >= num_verts) { + contours[j].end = i; + } + } + + typedef struct { + msdf_signedDistance min_distance; + msdf_EdgeSegment *near_edge; + double near_param; + } msdf_EdgePoint; + + typedef struct { + msdf_EdgeSegment *edges; + size_t edge_count; + } msdf_Contour; + + // process verts into series of contour-specific edge lists + msdf_Vec2 initial = {0, 0}; // fix this? + msdf_Contour *contour_data = allocCtx.alloc(sizeof(msdf_Contour) * contour_count, allocCtx.ctx); + double cscale = 64.0; + for (int i = 0; i < contour_count; i++) { + size_t count = contours[i].end - contours[i].start; + contour_data[i].edges = allocCtx.alloc(sizeof(msdf_EdgeSegment) * count, allocCtx.ctx); + contour_data[i].edge_count = 0; + + size_t k = 0; + for (int j = contours[i].start; j < contours[i].end; j++) { + msdf_EdgeSegment *e = &contour_data[i].edges[k]; + stbtt_vertex *v = &verts[j]; + e->type = v->type; + e->color = msdf_edgeColor_white; + + switch (v->type) { + case STBTT_vmove: { + msdf_Vec2 p = {v->x / cscale, v->y / cscale}; + memcpy(&initial, p, sizeof(msdf_Vec2)); + break; + } + + case STBTT_vline: { + msdf_Vec2 p = {v->x / cscale, v->y / cscale}; + memcpy(&e->p[0], initial, sizeof(msdf_Vec2)); + memcpy(&e->p[1], p, sizeof(msdf_Vec2)); + memcpy(&initial, p, sizeof(msdf_Vec2)); + contour_data[i].edge_count++; + k++; + break; + } + + case STBTT_vcurve: { + msdf_Vec2 p = {v->x / cscale, v->y / cscale}; + msdf_Vec2 c = {v->cx / cscale, v->cy / cscale}; + memcpy(&e->p[0], initial, sizeof(msdf_Vec2)); + memcpy(&e->p[1], c, sizeof(msdf_Vec2)); + memcpy(&e->p[2], p, sizeof(msdf_Vec2)); + + if ((e->p[0][0] == e->p[1][0] && e->p[0][1] == e->p[1][1]) || + (e->p[1][0] == e->p[2][0] && e->p[1][1] == e->p[2][1])) + { + e->p[1][0] = 0.5 * (e->p[0][0] + e->p[2][0]); + e->p[1][1] = 0.5 * (e->p[0][1] + e->p[2][1]); + } + + memcpy(&initial, p, sizeof(msdf_Vec2)); + contour_data[i].edge_count++; + k++; + break; + } + + case STBTT_vcubic: { + msdf_Vec2 p = {v->x / cscale, v->y / cscale}; + msdf_Vec2 c = {v->cx / cscale, v->cy / cscale}; + msdf_Vec2 c1 = {v->cx1 / cscale, v->cy1 / cscale}; + memcpy(&e->p[0], initial, sizeof(msdf_Vec2)); + memcpy(&e->p[1], c, sizeof(msdf_Vec2)); + memcpy(&e->p[2], c1, sizeof(msdf_Vec2)); + memcpy(&e->p[3], p, sizeof(msdf_Vec2)); + memcpy(&initial, p, sizeof(msdf_Vec2)); + contour_data[i].edge_count++; + k++; + break; + } + } + } + } + + // calculate edge-colors + uint64_t seed = 0; + double anglethreshold = 3.0; + double crossthreshold = sin(anglethreshold); + size_t corner_count = 0; + for (int i = 0; i < contour_count; ++i) { + for (int j = 0; j < contour_data[i].edge_count; ++j) { + corner_count++; + } + } + + int *corners = allocCtx.alloc(sizeof(int) * corner_count, allocCtx.ctx); + int cornerIndex = 0; + for (int i = 0; i < contour_count; ++i) { + + if (contour_data[i].edge_count > 0) { + msdf_Vec2 prev_dir, dir; + msdf_direction(prev_dir, &contour_data[i].edges[contour_data[i].edge_count - 1], 1); + + int index = 0; + for (int j = 0; j < contour_data[i].edge_count; ++j, ++index) { + msdf_EdgeSegment *e = &contour_data[i].edges[j]; + msdf_direction(dir, e, 0); + msdf_v2Norm(dir, dir); + msdf_v2Norm(prev_dir, prev_dir); + if (msdf_isCorner(prev_dir, dir, crossthreshold)) { + corners[cornerIndex++] = index; + } + msdf_direction(prev_dir, e, 1); + } + } + + if (cornerIndex == 0) { + for (int j = 0; j < contour_data[i].edge_count; ++j) { + contour_data[i].edges[j].color = msdf_edgeColor_white; + } + } else if (cornerIndex == 1) { + msdf_edgeColor colors[3] = {msdf_edgeColor_white, msdf_edgeColor_white}; + msdf_switchColor(&colors[0], &seed, msdf_edgeColor_black); + colors[2] = colors[0]; + msdf_switchColor(&colors[2], &seed, msdf_edgeColor_black); + + int corner = corners[0]; + if (contour_data[i].edge_count >= 3) { + int m = contour_data[i].edge_count; + for (int j = 0; j < m; ++j) { + contour_data[i].edges[(corner + j) % m].color = (colors + 1)[(int)(3 + 2.875 * i / (m - 1) - 1.4375 + .5) - 3]; + } + } else if (contour_data[i].edge_count >= 1) { + msdf_EdgeSegment *parts[7] = {NULL}; + msdf_edgeSplit(&contour_data[i].edges[0], parts[0 + 3 * corner], parts[1 + 3 * corner], parts[2 + 3 * corner]); + if (contour_data[i].edge_count >= 2) { + msdf_edgeSplit(&contour_data[i].edges[1], parts[3 - 3 * corner], parts[4 - 3 * corner], parts[5 - 3 * corner]); + parts[0]->color = parts[1]->color = colors[0]; + parts[2]->color = parts[3]->color = colors[1]; + parts[4]->color = parts[5]->color = colors[2]; + } else { + parts[0]->color = colors[0]; + parts[1]->color = colors[1]; + parts[2]->color = colors[2]; + } + if (allocCtx.free) { + allocCtx.free(contour_data[i].edges, allocCtx.ctx); + } + contour_data[i].edges = allocCtx.alloc(sizeof(msdf_EdgeSegment) * 7, allocCtx.ctx); + contour_data[i].edge_count = 0; + int index = 0; + for (int j = 0; parts[j]; ++j) { + memcpy(&contour_data[i].edges[index++], &parts[j], sizeof(msdf_EdgeSegment)); + contour_data[i].edge_count++; + } + } + } else { + int spline = 0; + int start = corners[0]; + int m = contour_data[i].edge_count; + msdf_edgeColor color = msdf_edgeColor_white; + msdf_switchColor(&color, &seed, msdf_edgeColor_black); + msdf_edgeColor initial_color = color; + for (int j = 0; j < m; ++j) { + int index = (start + j) % m; + if (spline + 1 < corner_count && corners[spline + 1] == index) { + ++spline; + + msdf_edgeColor s = (msdf_edgeColor)((spline == corner_count - 1) * initial_color); + msdf_switchColor(&color, &seed, s); + } + contour_data[i].edges[index].color = color; + } + } + } + + if (allocCtx.free) { + allocCtx.free(corners, allocCtx.ctx); + } + + // normalize shape + for (int i = 0; i < contour_count; i++) { + if (contour_data[i].edge_count == 1) { + msdf_EdgeSegment *parts[3] = {0}; + msdf_edgeSplit(&contour_data[i].edges[0], parts[0], parts[1], parts[2]); + if (allocCtx.free) { + allocCtx.free(contour_data[i].edges, allocCtx.ctx); + } + contour_data[i].edges = allocCtx.alloc(sizeof(msdf_EdgeSegment) * 3, allocCtx.ctx); + contour_data[i].edge_count = 3; + for (int j = 0; j < 3; j++) { + memcpy(&contour_data[i].edges[j], parts[j], sizeof(msdf_EdgeSegment)); + } + } + } + + // calculate windings + int *windings = allocCtx.alloc(sizeof(int) * contour_count, allocCtx.ctx); + for (int i = 0; i < contour_count; i++) { + size_t edge_count = contour_data[i].edge_count; + if (edge_count == 0) { + windings[i] = 0; + continue; + } + + double total = 0; + + if (edge_count == 1) { + msdf_Vec2 a, b, c; + msdf_point(a, &contour_data[i].edges[0], 0); + msdf_point(b, &contour_data[i].edges[0], 1 / 3.0); + msdf_point(c, &contour_data[i].edges[0], 2 / 3.0); + total += msdf_shoelace(a, b); + total += msdf_shoelace(b, c); + total += msdf_shoelace(c, a); + } else if (edge_count == 2) { + msdf_Vec2 a, b, c, d; + msdf_point(a, &contour_data[i].edges[0], 0); + msdf_point(b, &contour_data[i].edges[0], 0.5); + msdf_point(c, &contour_data[i].edges[1], 0); + msdf_point(d, &contour_data[i].edges[1], 0.5); + total += msdf_shoelace(a, b); + total += msdf_shoelace(b, c); + total += msdf_shoelace(c, d); + total += msdf_shoelace(d, a); + } else { + msdf_Vec2 prev; + msdf_point(prev, &contour_data[i].edges[edge_count - 1], 0); + for (int j = 0; j < edge_count; j++) { + msdf_Vec2 cur; + msdf_point(cur, &contour_data[i].edges[j], 0); + total += msdf_shoelace(prev, cur); + memcpy(prev, cur, sizeof(msdf_Vec2)); + } + } + + windings[i] = ((0 < total) - (total < 0)); // sign + } + + typedef struct { + double r, g, b; + double med; + } msdf_MultiDistance; + + msdf_MultiDistance *contour_sd; + contour_sd = allocCtx.alloc(sizeof(msdf_MultiDistance) * contour_count, allocCtx.ctx); + + float invRange = 1.0 / range; + + for (int y = 0; y < h; ++y) { + int row = iy0 > iy1 ? y : h - y - 1; + for (int x = 0; x < w; ++x) { + float a64 = 64.0; + msdf_Vec2 p = {(translateX + x + xoff) / (scale * a64), (translateY + y + yoff) / (scale * a64)}; + //p[0] = ; + //p[1] = ; + msdf_EdgePoint sr, sg, sb; + sr.near_edge = sg.near_edge = sb.near_edge = NULL; + sr.near_param = sg.near_param = sb.near_param = 0; + sr.min_distance.dist = sg.min_distance.dist = sb.min_distance.dist = MSDF_INF; + sr.min_distance.d = sg.min_distance.d = sb.min_distance.d = 1; + double d = fabs(MSDF_INF); + double neg_dist = -MSDF_INF; + double pos_dist = MSDF_INF; + int winding = 0; + + // calculate distance to contours from current point (and if its inside or outside of the shape?) + for (int j = 0; j < contour_count; ++j) { + msdf_EdgePoint r, g, b; + r.near_edge = g.near_edge = b.near_edge = NULL; + r.near_param = g.near_param = b.near_param = 0; + r.min_distance.dist = g.min_distance.dist = b.min_distance.dist = MSDF_INF; + r.min_distance.d = g.min_distance.d = b.min_distance.d = 1; + + for (int k = 0; k < contour_data[j].edge_count; ++k) { + msdf_EdgeSegment *e = &contour_data[j].edges[k]; + double param; + msdf_signedDistance distance; + distance.dist = MSDF_INF; + distance.d = 1; + + // calculate signed distance + switch (e->type) { + case STBTT_vline: { + distance = msdf_linearDist(e, p, ¶m); + break; + } + case STBTT_vcurve: { + distance = msdf_quadraticDist(e, p, ¶m); + break; + } + case STBTT_vcubic: { + distance = msdf_cubicDist(e, p, ¶m); + break; + } + } + + if (e->color & msdf_edgeColor_red && msdf_signedCompare(distance, r.min_distance)) { + r.min_distance = distance; + r.near_edge = e; + r.near_param = param; + } + if (e->color & msdf_edgeColor_green && msdf_signedCompare(distance, g.min_distance)) { + g.min_distance = distance; + g.near_edge = e; + g.near_param = param; + } + if (e->color & msdf_edgeColor_blue && msdf_signedCompare(distance, b.min_distance)) { + b.min_distance = distance; + b.near_edge = e; + b.near_param = param; + } + } + + if (msdf_signedCompare(r.min_distance, sr.min_distance)) { + sr = r; + } + if (msdf_signedCompare(g.min_distance, sg.min_distance)) { + sg = g; + } + if (msdf_signedCompare(b.min_distance, sb.min_distance)) { + sb = b; + } + + double med_min_dist = fabs(msdf_median(r.min_distance.dist, g.min_distance.dist, b.min_distance.dist)); + + if (med_min_dist < d) { + d = med_min_dist; + winding = -windings[j]; + } + + if (r.near_edge) { + msdf_distToPseudo(&r.min_distance, p, r.near_param, r.near_edge); + } + if (g.near_edge) { + msdf_distToPseudo(&g.min_distance, p, g.near_param, g.near_edge); + } + if (b.near_edge) { + msdf_distToPseudo(&b.min_distance, p, b.near_param, b.near_edge); + } + + med_min_dist = msdf_median(r.min_distance.dist, g.min_distance.dist, b.min_distance.dist); + contour_sd[j].r = r.min_distance.dist; + contour_sd[j].g = g.min_distance.dist; + contour_sd[j].b = b.min_distance.dist; + contour_sd[j].med = med_min_dist; + + if (windings[j] > 0 && med_min_dist >= 0 && fabs(med_min_dist) < fabs(pos_dist)) { + pos_dist = med_min_dist; + } + if (windings[j] < 0 && med_min_dist <= 0 && fabs(med_min_dist) < fabs(neg_dist)) { + neg_dist = med_min_dist; + } + } + + if (sr.near_edge) { + msdf_distToPseudo(&sr.min_distance, p, sr.near_param, sr.near_edge); + } + if (sg.near_edge) { + msdf_distToPseudo(&sg.min_distance, p, sg.near_param, sg.near_edge); + } + if (sb.near_edge) { + msdf_distToPseudo(&sb.min_distance, p, sb.near_param, sb.near_edge); + } + + msdf_MultiDistance msd; + msd.r = msd.g = msd.b = msd.med = MSDF_INF; + if (pos_dist >= 0 && fabs(pos_dist) <= fabs(neg_dist)) { + msd.med = MSDF_INF; + winding = 1; + for (int i = 0; i < contour_count; ++i) { + if (windings[i] > 0 && contour_sd[i].med > msd.med && fabs(contour_sd[i].med) < fabs(neg_dist)) { + msd = contour_sd[i]; + } + } + } else if (neg_dist <= 0 && fabs(neg_dist) <= fabs(pos_dist)) { + msd.med = -MSDF_INF; + winding = -1; + for (int i = 0; i < contour_count; ++i) { + if (windings[i] < 0 && contour_sd[i].med < msd.med && fabs(contour_sd[i].med) < fabs(pos_dist)) { + msd = contour_sd[i]; + } + } + } + + for (int i = 0; i < contour_count; ++i) { + if (windings[i] != winding && fabs(contour_sd[i].med) < fabs(msd.med)) { + msd = contour_sd[i]; + } + } + + if (msdf_median(sr.min_distance.dist, sg.min_distance.dist, sb.min_distance.dist) == msd.med) { + msd.r = sr.min_distance.dist; + msd.g = sg.min_distance.dist; + msd.b = sb.min_distance.dist; + } + + size_t index = 3 * ((row * w) + x); + + float mr = ((float)msd.r) * invRange + 0.5f; + float mg = ((float)msd.g) * invRange + 0.5f; + float mb = ((float)msd.b) * invRange + 0.5f; + bitmap[index + 0] = mr; + bitmap[index + 1] = mg; + bitmap[index + 2] = mb; + + } + } + + if (allocCtx.free) { + for (int i = 0; i < contour_count; i++) { + allocCtx.free(contour_data[i].edges, allocCtx.ctx); + } + allocCtx.free(contour_data, allocCtx.ctx); + allocCtx.free(contour_sd, allocCtx.ctx); + allocCtx.free(contours, allocCtx.ctx); + allocCtx.free(windings, allocCtx.ctx); + allocCtx.free(verts, allocCtx.ctx); + } + + // msdf error correction + typedef struct { + int x, y; + } msdf_Clash; + msdf_Clash *clashes = allocCtx.alloc(sizeof(msdf_Clash) * w * h, allocCtx.ctx); + size_t cindex = 0; + + double tx = MSDF_EDGE_THRESHOLD / (scale * range); + double ty = MSDF_EDGE_THRESHOLD / (scale * range); + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + if ((x > 0 && msdf_pixelClash(msdf_pixelAt(x, y, w, bitmap), msdf_pixelAt(msdf_max(x - 1, 0), y, w, bitmap), tx)) || (x < w - 1 && msdf_pixelClash(msdf_pixelAt(x, y, w, bitmap), msdf_pixelAt(msdf_min(x + 1, w - 1), y, w, bitmap), tx)) || (y > 0 && msdf_pixelClash(msdf_pixelAt(x, y, w, bitmap), msdf_pixelAt(x, msdf_max(y - 1, 0), w, bitmap), ty)) || (y < h - 1 && msdf_pixelClash(msdf_pixelAt(x, y, w, bitmap), msdf_pixelAt(x, msdf_min(y + 1, h - 1), w, bitmap), ty))) { + clashes[cindex].x = x; + clashes[cindex++].y = y; + } + } + } + + for (int i = 0; i < cindex; i++) { + size_t index = 3 * ((clashes[i].y * w) + clashes[i].x); + float med = msdf_median(bitmap[index], bitmap[index + 1], bitmap[index + 2]); + bitmap[index + 0] = med; + bitmap[index + 1] = med; + bitmap[index + 2] = med; + } + + if (allocCtx.free) { + allocCtx.free(clashes, allocCtx.ctx); + } + + result->glyphIdx = glyphIdx; + result->rgb = bitmap; + result->width = w; + result->height = h; + result->yOffset = translateY; + + return 1; +} +#endif +#endif // MSDF_H diff --git a/text_rendering/msdf_c/sample/fonts/Roboto-Regular.ttf b/text_rendering/msdf_c/sample/fonts/Roboto-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ddf4bfacb396e97546364ccfeeb9c31dfaea4c25 GIT binary patch literal 168260 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

S&jh1n&JeeMOkU4{=4@cYr6k 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≤FHXCuU9Qce=@vmZ{%9^5??OaVQJ8!4u8-w;yt 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

hfu6`64EU9U5Amz#@yDC! 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 literal 0 HcmV?d00001 diff --git a/text_rendering/msdf_c/sample/sample.c b/text_rendering/msdf_c/sample/sample.c new file mode 100644 index 0000000..bc88ef6 --- /dev/null +++ b/text_rendering/msdf_c/sample/sample.c @@ -0,0 +1,210 @@ +//#include "svpng.h" +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "stb_image_write.h" +#define STB_TRUETYPE_IMPLEMENTATION +#include "../stb_truetype.h" +#define MSDF_IMPLEMENTATION +#include "../msdf.h" + +#include "stdio.h" + + +#ifndef SAMPLE_ROOT +#define SAMPLE_ROOT "" +#endif + +typedef struct Range { + void* content; + size_t size; +} Range; + +Range g_fileRead(const char* fileName) { + Range range = {NULL, 0}; + + FILE* fileHandle = fopen(fileName, "rb"); + if (fileHandle == NULL) { + assert(!"File not fount"); + return range; + } + + fseek(fileHandle, 0, SEEK_END); // seek to end of file + size_t size = ftell(fileHandle); // get current file pointer + fseek(fileHandle, 0, SEEK_SET); // seek back to beginning of file + + if (size == 0) { + assert(!"File size zero"); + return range; + } + + void* mem = malloc(size); + size_t readSize = fread(mem, 1, size, fileHandle); + if (readSize == size) { + range.content = mem; + range.size = size; + } else { + free(mem); + } + fclose(fileHandle); + return range; +} + +static void* g_alloc(size_t size, void* ctx) { + return malloc(size); +} + +static void g_free(void* ptr, void* ctx) { + return free(ptr); +} + +float g_min(float a, float b) { + return a > b ? b : a; +} + +float g_max(float a, float b) { + return a > b ? a : b; +} + +float g_clamp(float val, float min, float max) { + return g_min(g_max(val, min), max); +} + +float g_median(float r, float g, float b) { + return g_max(g_min(r, g), g_min(g_max(r, g), b)); +} + +float g_map(float min, float max, float v) { + return (v - min) / (max - min); +} + +int main() { + stbtt_fontinfo stbttInfo; + + Range fontFile = g_fileRead("./fonts/Roboto-Regular.ttf"); + + if (fontFile.content == NULL) { + assert(!"could not load font from disk"); + return 1; + } + + if (!stbtt_InitFont(&stbttInfo, fontFile.content, stbtt_GetFontOffsetForIndex(fontFile.content, 0))) { + assert(!"Couldn't parse font"); + return 1; + } + + + int ascent, descent; + stbtt_GetFontVMetrics(&stbttInfo, &ascent, &descent, 0); + + int borderSize = 4; + int genSize = 32+borderSize; + float genScale = stbtt_ScaleForPixelHeight(&stbttInfo, genSize); + + // int glyph = 0x00e8; // è + int glyph = 0x069D; + + int glyphIdx = stbtt_FindGlyphIndex(&stbttInfo, glyph); + + msdf_AllocCtx allocCtx = {g_alloc, g_free, NULL}; + + + printf("bruh\n"); + + msdf_Result result; + int success = msdf_genGlyph(&result, &stbttInfo, glyphIdx, borderSize, genScale, 2.0f / genSize, &allocCtx); + + if (success == 0) { + assert(!"Failed to generate msdf glyph"); + return 1; + } + printf("bruh\n"); + +// FILE* fp = fopen(SAMPLE_ROOT "/sdf.png", "wb"); + + uint8_t* pixels = malloc(sizeof(uint8_t) * result.width * result.height * 3); + float scale = genSize; + float maxValue = 1.0 * (scale); + float transistionWidth = ((((((float) genSize) * 0.7f) + scale) / (scale * 2.0f))); + float transistionAbs = (transistionWidth - 0.5); + float transistStart = 0.5 - transistionAbs / 2; + float transistEnd = transistStart + transistionAbs; + + //float ff = expf(0.01); + for (int y = 0; y < result.height; y++) { + int yPos = result.width * 3 * y; + uint8_t* pixelRow = pixels + (y * result.width * 3); + for (int x = 0; x < result.width; x++) { + int indexSdf = yPos + (x * 3); + float r = result.rgb[indexSdf + 0]; + float g = result.rgb[indexSdf + 1]; + float b = result.rgb[indexSdf + 2]; + + + r = ((((r) + scale) / (scale * 2.0f))); + g = ((((g) + scale) / (scale * 2.0f))); + b = ((((b) + scale) / (scale * 2.0f))); + + if (r > transistStart) { + if (r > (transistEnd)) { + r = 1.0f; + } else { + r = 0.0f + (r - transistStart) / (transistionAbs); + } + } else { + r = 0.0f; + } + if (g > transistStart) { + if (g > (transistEnd)) { + g = 1.0f; + } else { + g = 0.0f + (g - transistStart) / (transistionAbs); + } + } else { + g = 0.0f; + } + if (b > transistStart) { + if (b > (transistEnd)) { + b = 1.0f; + } else { + b = 0.0f + (b - transistStart) / (transistionAbs); + } + } else { + b = 0.0f; + } + + pixelRow[x * 3 + 0] = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f; + pixelRow[x * 3 + 1] = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f; + pixelRow[x * 3 + 2] = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f; + } + } +// printf("bruh\n"); +// +// svpng(fp, result.width, result.height, pixels, 0); + stbi_write_png("./sdf.png", result.width, result.height, 3, pixels, 3*result.width); +// fclose(fp); + + // apply sdf +// +// FILE* finalImage = fopen(SAMPLE_ROOT "/final.png", "wb"); +// +// uint8_t* rgbaFinal = malloc(sizeof(uint8_t) * result.width * result.height * 4); +// +// for (int y = 0; y < result.height; y++) { +// uint8_t* pixelRow = pixels + (y * result.width * 3); +// uint8_t* rgbaFinalRow = rgbaFinal + (y * result.width * 4); +// for (int x = 0; x < result.width; x++) { +// float r = ((float)pixelRow[x * 3 + 0]) / 255.0f;// = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f; +// float g = ((float)pixelRow[x * 3 + 1]) / 255.0f;// = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f; +// float b = ((float)pixelRow[x * 3 + 2]) / 255.0f;// = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f; +// float dist = g_median(r, g, b); +// float opacity = g_clamp(dist - 0.5f, 0, 1) * 2.0f; +// rgbaFinalRow[x * 4 + 0] = 0;//255.0f; +// rgbaFinalRow[x * 4 + 1] = 0;//255.0f; +// rgbaFinalRow[x * 4 + 2] = 0;//255.0f; +// rgbaFinalRow[x * 4 + 3] = opacity * 255.0f; +// +// } +// } +// svpng(finalImage, result.width, result.height, rgbaFinal, 1); +// fclose(finalImage); + return 0; +} \ No newline at end of file diff --git a/text_rendering/msdf_c/sample/sdf.png b/text_rendering/msdf_c/sample/sdf.png new file mode 100644 index 0000000000000000000000000000000000000000..9040c3e394f5d9423ea71e2288bfc8dc48509029 GIT binary patch literal 600 zcmV-e0;m0nP)b z1*!}Tj~N*L<3_XL>X{hG1?1~wVMs$*3UsR@K_|?Ds$gN5iK15Qz#XO?vl%)t43J=8 zSnsj!D#PVja4DqVQ2noJxPSk_gN#B#U}?A%FvOCQCU{O@m<ce z&TR|?bpqXnVy&LuQ7@ydj9Uro1gZe)w6kMSR|hNh^4hAr^)qqd0fRRV3xNjVOSfCMx`h2;+0M8f6ss7P z;?rrr-kakfhpp{@25bPQPObl17AL&6Zrch@Pyb2qrx%0Qwry(LUTkysI1N$SDC$d~4#TRk;jv&M`cMNw6@qqNpih zI2y{N!k~igtGf&gySJ-&F}$44fDOP)c&xIv3=D4=7+7I)B$U*L89>?83%{M%(>Mb| mIJm-r=q0Uo0LJkim}UTurm;Z#Y|@wj0000 + +// 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/text_rendering/msdf_c/sample/svpng.h b/text_rendering/msdf_c/sample/svpng.h new file mode 100644 index 0000000..aa23324 --- /dev/null +++ b/text_rendering/msdf_c/sample/svpng.h @@ -0,0 +1,110 @@ +/* +Copyright (C) 2017 Milo Yip. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of pngout nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*! \file + \brief svpng() is a minimalistic C function for saving RGB/RGBA image into uncompressed PNG. + \author Milo Yip + \version 0.1.1 + \copyright MIT license + \sa http://github.com/miloyip/svpng +*/ + +#ifndef SVPNG_INC_ +#define SVPNG_INC_ + +/*! \def SVPNG_LINKAGE + \brief User customizable linkage for svpng() function. + By default this macro is empty. + User may define this macro as static for static linkage, + and/or inline in C99/C++, etc. +*/ +#ifndef SVPNG_LINKAGE +#define SVPNG_LINKAGE +#endif + +/*! \def SVPNG_OUTPUT + \brief User customizable output stream. + By default, it uses C file descriptor and fputc() to output bytes. + In C++, for example, user may use std::ostream or std::vector instead. +*/ +#ifndef SVPNG_OUTPUT +#include +#define SVPNG_OUTPUT FILE* fp +#endif + +/*! \def SVPNG_PUT + \brief Write a byte +*/ +#ifndef SVPNG_PUT +#define SVPNG_PUT(u) fputc(u, fp) +#endif + + +/*! + \brief Save a RGB/RGBA image in PNG format. + \param SVPNG_OUTPUT Output stream (by default using file descriptor). + \param w Width of the image. (<16383) + \param h Height of the image. + \param img Image pixel data in 24-bit RGB or 32-bit RGBA format. + \param alpha Whether the image contains alpha channel. +*/ +SVPNG_LINKAGE void svpng(SVPNG_OUTPUT, unsigned w, unsigned h, const unsigned char* img, int alpha) { + static const unsigned t[] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, + /* CRC32 Table */ 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c }; + unsigned a = 1, b = 0, c, p = w * (alpha ? 4 : 3) + 1, x, y, i; /* ADLER-a, ADLER-b, CRC, pitch */ +#define SVPNG_U8A(ua, l) for (i = 0; i < l; i++) SVPNG_PUT((ua)[i]); +#define SVPNG_U32(u) do { SVPNG_PUT((u) >> 24); SVPNG_PUT(((u) >> 16) & 255); SVPNG_PUT(((u) >> 8) & 255); SVPNG_PUT((u) & 255); } while(0) +#define SVPNG_U8C(u) do { SVPNG_PUT(u); c ^= (u); c = (c >> 4) ^ t[c & 15]; c = (c >> 4) ^ t[c & 15]; } while(0) +#define SVPNG_U8AC(ua, l) for (i = 0; i < l; i++) SVPNG_U8C((ua)[i]) +#define SVPNG_U16LC(u) do { SVPNG_U8C((u) & 255); SVPNG_U8C(((u) >> 8) & 255); } while(0) +#define SVPNG_U32C(u) do { SVPNG_U8C((u) >> 24); SVPNG_U8C(((u) >> 16) & 255); SVPNG_U8C(((u) >> 8) & 255); SVPNG_U8C((u) & 255); } while(0) +#define SVPNG_U8ADLER(u) do { SVPNG_U8C(u); a = (a + (u)) % 65521; b = (b + a) % 65521; } while(0) +#define SVPNG_BEGIN(s, l) do { SVPNG_U32(l); c = ~0U; SVPNG_U8AC(s, 4); } while(0) +#define SVPNG_END() SVPNG_U32(~c) + SVPNG_U8A("\x89PNG\r\n\32\n", 8); /* Magic */ + SVPNG_BEGIN("IHDR", 13); /* IHDR chunk { */ + SVPNG_U32C(w); SVPNG_U32C(h); /* Width & Height (8 bytes) */ + SVPNG_U8C(8); SVPNG_U8C(alpha ? 6 : 2); /* Depth=8, Color=True color with/without alpha (2 bytes) */ + SVPNG_U8AC("\0\0\0", 3); /* Compression=Deflate, Filter=No, Interlace=No (3 bytes) */ + SVPNG_END(); /* } */ + SVPNG_BEGIN("IDAT", 2 + h * (5 + p) + 4); /* IDAT chunk { */ + SVPNG_U8AC("\x78\1", 2); /* Deflate block begin (2 bytes) */ + for (y = 0; y < h; y++) { /* Each horizontal line makes a block for simplicity */ + SVPNG_U8C(y == h - 1); /* 1 for the last block, 0 for others (1 byte) */ + SVPNG_U16LC(p); SVPNG_U16LC(~p); /* Size of block in little endian and its 1's complement (4 bytes) */ + SVPNG_U8ADLER(0); /* No filter prefix (1 byte) */ + for (x = 0; x < p - 1; x++, img++) + SVPNG_U8ADLER(*img); /* Image pixel data */ + } + SVPNG_U32C((b << 16) | a); /* Deflate block end with adler (4 bytes) */ + SVPNG_END(); /* } */ + SVPNG_BEGIN("IEND", 0); SVPNG_END(); /* IEND chunk {} */ +} + +#endif /* SVPNG_INC_ */ \ No newline at end of file diff --git a/text_rendering/stb_truetype.h b/text_rendering/msdf_c/stb_truetype.h similarity index 99% rename from text_rendering/stb_truetype.h rename to text_rendering/msdf_c/stb_truetype.h index bbf2284..5e2a2e4 100644 --- a/text_rendering/stb_truetype.h +++ b/text_rendering/msdf_c/stb_truetype.h @@ -5074,4 +5074,4 @@ 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. ------------------------------------------------------------------------------ -*/ +*/ \ No newline at end of file