From c7ce84c1d067a19220abb6dbbf87c4118a2e14fe Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Thu, 14 Sep 2023 03:04:49 +0000 Subject: automatic import of stb --- .gitignore | 1 + 1194.patch | 233 +++++++++++++++++ 1195.patch | 59 +++++ 1196.patch | 22 ++ 1198.patch | 24 ++ 1223.patch | 59 +++++ 1230.patch | 32 +++ 1236.patch | 37 +++ 1297.patch | 244 +++++++++++++++++ sources | 1 + stb.spec | 872 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 11 files changed, 1584 insertions(+) create mode 100644 1194.patch create mode 100644 1195.patch create mode 100644 1196.patch create mode 100644 1198.patch create mode 100644 1223.patch create mode 100644 1230.patch create mode 100644 1236.patch create mode 100644 1297.patch create mode 100644 sources create mode 100644 stb.spec diff --git a/.gitignore b/.gitignore index e69de29..92930b7 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +/stb-8b5f1f37b5b75829fc72d38e7b5d4bcbf8a26d55.tar.gz diff --git a/1194.patch b/1194.patch new file mode 100644 index 0000000..364d026 --- /dev/null +++ b/1194.patch @@ -0,0 +1,233 @@ +From 3d401e71452d890eaf0bc50b11788cb08a6c2fed Mon Sep 17 00:00:00 2001 +From: "Benjamin A. Beasley" +Date: Tue, 17 Aug 2021 21:30:44 -0400 +Subject: [PATCH] =?UTF-8?q?Fix=20undefined=20behavior=20from=20array=20?= + =?UTF-8?q?=E2=80=9Cshape-punning=E2=80=9D?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +In stb_voxel_render.h, there were three cases where a 2D array of +dimension [X][Y] was iterated as a 1D array of dimension [1][X*Y]. While +this is clever and is correct in terms of the actual memory layout, a +second index outside the corresponding dimension ([i][j], j >= Y]) +actually produces undefined behavior and gives the compiler freedom to +do all sorts of terrible things. + +The same thing happens in stb_tilemap_editor.h, +tests/caveview/cave_mesher.c, and tests/resample_test.cpp. + +Prior to this commit, a compiler warning regarding the undefined +behavior appears on gcc 11.2.1 for at least some of these cases when the +tests are compiled with -Waggressive-loop-optimizations (included in +-Wall). + +This commit fixes the undefined behavior by iterating these 2D arrays +with the conventional nested loops. +--- + stb_tilemap_editor.h | 35 +++++++++++++++++++---------------- + stb_voxel_render.h | 36 +++++++++++++++++++++--------------- + tests/caveview/cave_mesher.c | 26 ++++++++++++++------------ + tests/resample_test.cpp | 15 +++++++++------ + 4 files changed, 63 insertions(+), 49 deletions(-) + +diff --git a/stb_tilemap_editor.h b/stb_tilemap_editor.h +index fbd3388084..0b8c2ca997 100644 +--- a/stb_tilemap_editor.h ++++ b/stb_tilemap_editor.h +@@ -1066,14 +1066,15 @@ stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacin + + void stbte_set_background_tile(stbte_tilemap *tm, short id) + { +- int i; ++ int i, j; + STBTE_ASSERT(id >= -1); + // STBTE_ASSERT(id < 32768); + if (id < -1) + return; +- for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i) +- if (tm->data[0][i][0] == -1) +- tm->data[0][i][0] = id; ++ for (i=0; i < STBTE_MAX_TILEMAP_X; ++i) ++ for (j=0; j < STBTE_MAX_TILEMAP_Y; ++j) ++ if (tm->data[i][j][0] == -1) ++ tm->data[i][j][0] = id; + tm->background_tile = id; + } + +@@ -1212,18 +1213,20 @@ void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y) + + void stbte_clear_map(stbte_tilemap *tm) + { +- int i,j; +- for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i) { +- tm->data[0][i][0] = tm->background_tile; +- for (j=1; j < tm->num_layers; ++j) +- tm->data[0][i][j] = STBTE__NO_TILE; +- for (j=0; j < STBTE_MAX_PROPERTIES; ++j) +- tm->props[0][i][j] = 0; +- #ifdef STBTE_ALLOW_LINK +- tm->link[0][i].x = -1; +- tm->link[0][i].y = -1; +- tm->linkcount[0][i] = 0; +- #endif ++ int i,j,k; ++ for (i=0; i < STBTE_MAX_TILEMAP_X; ++i) { ++ for (j=0; j < STBTE_MAX_TILEMAP_Y; ++j) { ++ tm->data[i][j][0] = tm->background_tile; ++ for (k=1; k < tm->num_layers; ++k) ++ tm->data[i][j][k] = STBTE__NO_TILE; ++ for (k=0; k < STBTE_MAX_PROPERTIES; ++k) ++ tm->props[i][j][k] = 0; ++ #ifdef STBTE_ALLOW_LINK ++ tm->link[i][j].x = -1; ++ tm->link[i][j].y = -1; ++ tm->linkcount[i][j] = 0; ++ #endif ++ } + } + } + +diff --git a/stb_voxel_render.h b/stb_voxel_render.h +index 2e7a372f83..51011091f7 100644 +--- a/stb_voxel_render.h ++++ b/stb_voxel_render.h +@@ -3126,15 +3126,17 @@ static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_po + stbvox_mesh_vertex vmesh[6][4]; + stbvox_rotate rotate = { 0,0,0,0 }; + unsigned char simple_rot = rot; +- int i; ++ int i, j; + // we only need to do this for the displayed faces, but it's easier + // to just do it up front; @OPTIMIZE check if it's faster to do it + // for visible faces only +- for (i=0; i < 6*4; ++i) { +- int vert = stbvox_vertex_selector[0][i]; +- vert = stbvox_rotate_vertex[vert][rot]; +- vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i] +- + stbvox_geometry_vheight[geo][vert]; ++ for (i=0; i < 6; ++i) { ++ for (j=0; j < 4; ++j) { ++ int vert = stbvox_vertex_selector[i][j]; ++ vert = stbvox_rotate_vertex[vert][rot]; ++ vmesh[i][j] = stbvox_vmesh_pre_vheight[i][j] ++ + stbvox_geometry_vheight[geo][vert]; ++ } + } + + basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z, 0,0); +@@ -3275,11 +3277,13 @@ static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_po + + // build vertex mesh + { +- int i; +- for (i=0; i < 6*4; ++i) { +- int vert = stbvox_vertex_selector[0][i]; +- vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i] +- + cube[vert]; ++ int i, j; ++ for (i=0; i < 6; ++i) { ++ for (j=0; j < 4; ++j) { ++ int vert = stbvox_vertex_selector[i][j]; ++ vmesh[i][j] = stbvox_vmesh_pre_vheight[i][j] ++ + cube[vert]; ++ } + } + } + +@@ -3541,10 +3545,12 @@ int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n) + + void stbvox_reset_buffers(stbvox_mesh_maker *mm) + { +- int i; +- for (i=0; i < STBVOX_MAX_MESHES*STBVOX_MAX_MESH_SLOTS; ++i) { +- mm->output_cur[0][i] = 0; +- mm->output_buffer[0][i] = 0; ++ int i, j; ++ for (i=0; i < STBVOX_MAX_MESHES; ++i) { ++ for (j=0; j < STBVOX_MAX_MESH_SLOTS; ++j) { ++ mm->output_cur[i][j] = 0; ++ mm->output_buffer[i][j] = 0; ++ } + } + } + +diff --git a/tests/caveview/cave_mesher.c b/tests/caveview/cave_mesher.c +index 1f76c89812..bbf79898b6 100644 +--- a/tests/caveview/cave_mesher.c ++++ b/tests/caveview/cave_mesher.c +@@ -802,7 +802,7 @@ void remap_in_place(int bt, int rm) + + void mesh_init(void) + { +- int i; ++ int i, j; + + chunk_cache_mutex = SDL_CreateMutex(); + chunk_get_mutex = SDL_CreateMutex(); +@@ -814,17 +814,19 @@ void mesh_init(void) + } + //effective_blocktype[50] = 0; // delete torches + +- for (i=0; i < 6*256; ++i) { +- if (minecraft_tex1_for_blocktype[0][i] == 40) +- minecraft_color_for_blocktype[0][i] = 38 | 64; // apply to tex1 +- if (minecraft_tex1_for_blocktype[0][i] == 39) +- minecraft_color_for_blocktype[0][i] = 39 | 64; // apply to tex1 +- if (minecraft_tex1_for_blocktype[0][i] == 105) +- minecraft_color_for_blocktype[0][i] = 63; // emissive +- if (minecraft_tex1_for_blocktype[0][i] == 212) +- minecraft_color_for_blocktype[0][i] = 63; // emissive +- if (minecraft_tex1_for_blocktype[0][i] == 80) +- minecraft_color_for_blocktype[0][i] = 63; // emissive ++ for (i=0; i < 6; ++i) { ++ for (j=0; j < 256; ++j) { ++ if (minecraft_tex1_for_blocktype[i][j] == 40) ++ minecraft_color_for_blocktype[i][j] = 38 | 64; // apply to tex1 ++ if (minecraft_tex1_for_blocktype[i][j] == 39) ++ minecraft_color_for_blocktype[i][j] = 39 | 64; // apply to tex1 ++ if (minecraft_tex1_for_blocktype[i][j] == 105) ++ minecraft_color_for_blocktype[i][j] = 63; // emissive ++ if (minecraft_tex1_for_blocktype[i][j] == 212) ++ minecraft_color_for_blocktype[i][j] = 63; // emissive ++ if (minecraft_tex1_for_blocktype[i][j] == 80) ++ minecraft_color_for_blocktype[i][j] = 63; // emissive ++ } + } + + for (i=0; i < 6; ++i) { +diff --git a/tests/resample_test.cpp b/tests/resample_test.cpp +index 21f874f18b..bb8ad82ef6 100644 +--- a/tests/resample_test.cpp ++++ b/tests/resample_test.cpp +@@ -646,8 +646,9 @@ void verify_box(void) + + resample_88(STBIR_FILTER_BOX); + +- for (i=0; i < sizeof(image88); ++i) +- STBIR_ASSERT(image88[0][i] == output88[0][i]); ++ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i) ++ for (j=0; j < sizeof(image88[0]); ++j) ++ STBIR_ASSERT(image88[i][j] == output88[i][j]); + + t = 0; + for (j=0; j < 4; ++j) +@@ -685,12 +686,14 @@ void test_filters(void) + + mtsrand(0); + +- for (i=0; i < sizeof(image88); ++i) +- image88[0][i] = mtrand() & 255; ++ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i) ++ for (j=0; j < sizeof(image88[0]); ++j) ++ image88[i][j] = mtrand() & 255; + verify_box(); + +- for (i=0; i < sizeof(image88); ++i) +- image88[0][i] = 0; ++ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i) ++ for (j=0; j < sizeof(image88[0]); ++j) ++ image88[i][j] = 0; + image88[4][4] = 255; + verify_box(); + diff --git a/1195.patch b/1195.patch new file mode 100644 index 0000000..312eacd --- /dev/null +++ b/1195.patch @@ -0,0 +1,59 @@ +From 5818c4e48a7e7d4c21aacf3cd6f1c7e12f770924 Mon Sep 17 00:00:00 2001 +From: "Benjamin A. Beasley" +Date: Wed, 18 Aug 2021 13:22:14 -0400 +Subject: [PATCH] Fix misleading indentation in stb_divide.h +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +With -Wmisleading-indentation (part of -Wall), gcc 11.2.1 warns: + + In file included from test_c_compilation.c:22: + ../stb_divide.h: In function 'test': + ../stb_divide.h:316:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation] + 316 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a); + | ^~ + ../stb_divide.h:316:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' + 316 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a); + | ^~~~~~~~~~~~ + ../stb_divide.h:318:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation] + 318 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b); + | ^~ + ../stb_divide.h:318:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' + 318 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b); + | ^~~~~~~~~~~~ + ../stb_divide.h:320:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation] + 320 | if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1); + | ^~ + ../stb_divide.h:320:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' + 320 | if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1); + | ^~~~~~~~~~~~ + +This commit moves each call to stbdiv_check(…) to the following line to +make clear that it is unconditional and to resolve the warning. +--- + stb_divide.h | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +diff --git a/stb_divide.h b/stb_divide.h +index 6a51e3f2e..4c24143c4 100644 +--- a/stb_divide.h ++++ b/stb_divide.h +@@ -313,11 +313,14 @@ void test(int a, int b) + int q,r; + if (show) printf("(%+11d,%+d) | ", a,b); + q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b); +- if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a); ++ if (show) printf("(%+11d,%+2d) ", q,r); ++ stbdiv_check(q,r,a,b, "trunc",a); + q = stb_div_floor(a,b), r = stb_mod_floor(a,b); +- if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b); ++ if (show) printf("(%+11d,%+2d) ", q,r); ++ stbdiv_check(q,r,a,b, "floor",b); + q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b); +- if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1); ++ if (show) printf("(%+11d,%+2d)\n", q,r); ++ stbdiv_check(q,r,a,b, "euclidean",1); + } + + void testh(int a, int b) diff --git a/1196.patch b/1196.patch new file mode 100644 index 0000000..705f67e --- /dev/null +++ b/1196.patch @@ -0,0 +1,22 @@ +From 49c16b0c2a4efa72d0ce6ea05d3fa7d9e8fc6cba Mon Sep 17 00:00:00 2001 +From: "Benjamin A. Beasley" +Date: Thu, 19 Aug 2021 12:57:27 -0400 +Subject: [PATCH] Add missing initializer braces in stb_easy_font.h + +--- + stb_easy_font.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/stb_easy_font.h b/stb_easy_font.h +index b66325847b..5f7511560a 100644 +--- a/stb_easy_font.h ++++ b/stb_easy_font.h +@@ -202,7 +202,7 @@ static int stb_easy_font_print(float x, float y, char *text, unsigned char color + float start_x = x; + int offset = 0; + +- stb_easy_font_color c = { 255,255,255,255 }; // use structure copying to avoid needing depending on memcpy() ++ stb_easy_font_color c = { { 255,255,255,255 } }; // use structure copying to avoid needing depending on memcpy() + if (color) { c.c[0] = color[0]; c.c[1] = color[1]; c.c[2] = color[2]; c.c[3] = color[3]; } + + while (*text && offset < vbuf_size) { diff --git a/1198.patch b/1198.patch new file mode 100644 index 0000000..b94d2be --- /dev/null +++ b/1198.patch @@ -0,0 +1,24 @@ +From f9a5eaee846f1a19fbcda2f5adb5238a94cbbc2f Mon Sep 17 00:00:00 2001 +From: "Benjamin A. Beasley" +Date: Tue, 24 Aug 2021 11:45:48 -0400 +Subject: [PATCH] Fix signature of dummy realloc() for STB_VORBIS_NO_CRT + +--- + stb_vorbis.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/stb_vorbis.c b/stb_vorbis.c +index 3e5c2504c..c1703426e 100644 +--- a/stb_vorbis.c ++++ b/stb_vorbis.c +@@ -594,8 +594,8 @@ enum STBVorbisError + #else // STB_VORBIS_NO_CRT + #define NULL 0 + #define malloc(s) 0 +- #define free(s) ((void) 0) +- #define realloc(s) 0 ++ #define free(p) ((void) 0) ++ #define realloc(p, s) 0 + #endif // STB_VORBIS_NO_CRT + + #include diff --git a/1223.patch b/1223.patch new file mode 100644 index 0000000..b5282e1 --- /dev/null +++ b/1223.patch @@ -0,0 +1,59 @@ +From 8075c3442ffeadab7594e1fe3ad13344f9c9c783 Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Thu, 7 Oct 2021 13:00:32 -0700 +Subject: [PATCH] Fixes two stb_image issues that could occur with specially + constructed HDR and PGM files. + +Signed-off-by: Neil Bickford +--- + stb_image.h | 17 ++++++++++++----- + 1 file changed, 12 insertions(+), 5 deletions(-) + +diff --git a/stb_image.h b/stb_image.h +index d60371b95..8518c05e7 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -108,7 +108,7 @@ RECENT REVISION HISTORY: + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus +- Josh Tobin Matthew Gregan github:poppolopoppo ++ Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra +@@ -7187,12 +7187,12 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re + // Run + value = stbi__get8(s); + count -= 128; +- if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } ++ if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump +- if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } ++ if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } +@@ -7446,10 +7446,17 @@ static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); +- stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8)); ++ if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { ++ STBI_FREE(out); ++ return stbi__errpuc("bad PNM", "PNM file truncated"); ++ } + + if (req_comp && req_comp != s->img_n) { +- out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); ++ if (ri->bits_per_channel == 16) { ++ out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); ++ } else { ++ out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); ++ } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; diff --git a/1230.patch b/1230.patch new file mode 100644 index 0000000..c4846bb --- /dev/null +++ b/1230.patch @@ -0,0 +1,32 @@ +From b5d9d9719b001c67ca922df547a85a0fae364997 Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Fri, 15 Oct 2021 11:04:41 -0700 +Subject: [PATCH] stb_image PNG: Checks for invalid DEFLATE codes. + +Specifically, this rejects length codes 286 and 287, and distance codes 30 and 31. +This avoids a scenario in which a file could contain a table in which +0 corresponded to length code 287, which would result in writing 0 bits. + +Signed-off-by: Neil Bickford +--- + stb_image.h | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/stb_image.h b/stb_image.h +index d60371b95..ab616c56d 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -4256,11 +4256,12 @@ static int stbi__parse_huffman_block(stbi__zbuf *a) + a->zout = zout; + return 1; + } ++ if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); +- if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); ++ if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); diff --git a/1236.patch b/1236.patch new file mode 100644 index 0000000..37cc507 --- /dev/null +++ b/1236.patch @@ -0,0 +1,37 @@ +From 5cf3af3181f7a0fb8d59ca5fe8daa011c1918d19 Mon Sep 17 00:00:00 2001 +From: Ryan Wiedemann +Date: Mon, 25 Oct 2021 22:11:48 -0600 +Subject: [PATCH] Predeclare stbhw__process struct to fix warnings + +A subset of the warnings as produced by `clang`. +``` +./../stb_herringbone_wang_tile.h:369:41: warning: declaration of 'struct stbhw__process' will not be visible outside of this function [-Wvisibility] +typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos, + ^ +./../stb_herringbone_wang_tile.h:401:43: warning: incompatible pointer types passing 'stbhw__process *' (aka 'struct stbhw__process *') to parameter of type 'struct stbhw__process *' [-Wincompatible-pointer-types] + p->process_h_rect(p, xpos, ypos, a,b,c,d,e,f); + ^ +./../stb_herringbone_wang_tile.h:425:43: warning: incompatible pointer types passing 'stbhw__process *' (aka 'struct stbhw__process *') to parameter of type 'struct stbhw__process *' [-Wincompatible-pointer-types] + p->process_v_rect(p, xpos, ypos, a,b,c,d,e,f); + ^ +./../stb_herringbone_wang_tile.h:929:21: warning: incompatible pointer types assigning to 'stbhw__process_rect *' (aka 'void (*)(struct stbhw__process *, int, int, int, int, int, int, int, int)') from 'void (stbhw__process *, int, int, int, int, int, int, int, int)' (aka 'void (struct stbhw__process *, int, int, int, int, int, int, int, int)') [-Wincompatible-pointer-types] + p.process_h_rect = stbhw__parse_h_rect; + ^ ~~~~~~~~~~~~~~~~~~~ +``` +--- + stb_herringbone_wang_tile.h | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/stb_herringbone_wang_tile.h b/stb_herringbone_wang_tile.h +index 5517941f7a..92c238bb24 100644 +--- a/stb_herringbone_wang_tile.h ++++ b/stb_herringbone_wang_tile.h +@@ -366,6 +366,8 @@ STBHW_EXTERN const char *stbhw_get_last_error(void) + // need to try to do more sophisticated parsing of edge color + // markup or something. + ++struct stbhw__process; ++ + typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos, + int a, int b, int c, int d, int e, int f); + diff --git a/1297.patch b/1297.patch new file mode 100644 index 0000000..9fe840c --- /dev/null +++ b/1297.patch @@ -0,0 +1,244 @@ +From fa43122a169eb79ced5789f2f261cee7fd4db221 Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Tue, 22 Feb 2022 23:48:42 -0800 +Subject: [PATCH 1/4] Add checks for PNM integer read overflows, add a 1GB + limit on IDAT chunk sizes to fix an OOM issue, and check for a situation + where a sequence of bad Huffman code reads could result in a left shift by a + negative number. + +--- + stb_image.h | 8 ++++++++ + 1 file changed, 8 insertions(+) + +diff --git a/stb_image.h b/stb_image.h +index d60371b95..6321f5e02 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -2283,6 +2283,7 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__ + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; ++ if (s > j->code_bits) return stbi__err("bad huffman code","Combined length longer than code bits available"); + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); +@@ -5116,6 +5117,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } ++ if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; +@@ -7486,6 +7488,8 @@ static int stbi__pnm_getinteger(stbi__context *s, char *c) + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); ++ if((value > 214748364) || (value == 214748364 && *c > '7')) ++ return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +@@ -7516,9 +7520,13 @@ static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width ++ if(*x == 0) ++ return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height ++ if (*y == 0) ++ return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + +From 83739b31eeddaaf683948051661ece39af6795cd Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Wed, 23 Feb 2022 00:53:34 -0800 +Subject: [PATCH 2/4] Add range checks to fix a few crash issues in stb_image + issues 1289 and 1291 + +--- + stb_image.h | 10 ++++++++-- + 1 file changed, 8 insertions(+), 2 deletions(-) + +diff --git a/stb_image.h b/stb_image.h +index 6321f5e02..800c83db3 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -1985,9 +1985,12 @@ static int stbi__build_huffman(stbi__huffman *h, int *count) + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) +- for (i=0; i < 16; ++i) +- for (j=0; j < count[i]; ++j) ++ for (i=0; i < 16; ++i) { ++ for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); ++ if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); ++ } ++ } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) +@@ -2112,6 +2115,8 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; ++ if(c < 0 || c >= 256) // symbol id out of bounds! ++ return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol +@@ -3103,6 +3108,7 @@ static int stbi__process_marker(stbi__jpeg *z, int m) + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } ++ if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + +From 2cdd738fd112e11bec8d7b2ee96449741a203ee2 Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Wed, 23 Feb 2022 23:48:49 -0800 +Subject: [PATCH 3/4] Add checks for signed integer overflow; further guard + against cases where stbi__grow_buffer_unsafe doesn't read all bits required. + +--- + stb_image.h | 27 ++++++++++++++++++++++++++- + 1 file changed, 26 insertions(+), 1 deletion(-) + +diff --git a/stb_image.h b/stb_image.h +index 800c83db3..9d10099bb 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -1063,6 +1063,23 @@ static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) + } + #endif + ++// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. ++static int stbi__addints_valid(int a, int b) ++{ ++ if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow ++ if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. ++ return a <= INT_MAX - b; ++} ++ ++// returns 1 if the product of two signed shorts is valid, 0 on overflow. ++static int stbi__mul2shorts_valid(short a, short b) ++{ ++ if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow ++ if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid ++ if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN ++ return a >= SHRT_MIN / b; ++} ++ + // stbi__err - error + // stbi__errpf - error returning pointer to float + // stbi__errpuc - error returning pointer to unsigned char +@@ -2135,6 +2152,7 @@ stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n) + unsigned int k; + int sgn; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); ++ if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); +@@ -2149,6 +2167,7 @@ stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) + { + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); ++ if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; +@@ -2160,6 +2179,7 @@ stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) + { + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); ++ if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; +@@ -2197,8 +2217,10 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; ++ if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; ++ if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec +@@ -2212,6 +2234,7 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length ++ if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location +@@ -2251,8 +2274,10 @@ static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__ + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + ++ if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; ++ if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient +@@ -2287,8 +2312,8 @@ static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__ + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length ++ if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; +- if (s > j->code_bits) return stbi__err("bad huffman code","Combined length longer than code bits available"); + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + +From 51e438b04b50eb98540f6df6057004214e9cc81c Mon Sep 17 00:00:00 2001 +From: Neil Bickford +Date: Fri, 25 Feb 2022 14:27:31 -0800 +Subject: [PATCH 4/4] Zero-initialize stbi__jpeg to avoid intermittent errors + found by fuzz-testing + +--- + stb_image.h | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/stb_image.h b/stb_image.h +index 9d10099bb..631e4e51c 100644 +--- a/stb_image.h ++++ b/stb_image.h +@@ -4008,6 +4008,7 @@ static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int re + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); ++ memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); +@@ -4021,6 +4022,7 @@ static int stbi__jpeg_test(stbi__context *s) + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); ++ memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); +@@ -4046,6 +4048,7 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); ++ memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); diff --git a/sources b/sources new file mode 100644 index 0000000..b53e2df --- /dev/null +++ b/sources @@ -0,0 +1 @@ +5e0a1100edc552cd25d392ab615f8eec stb-8b5f1f37b5b75829fc72d38e7b5d4bcbf8a26d55.tar.gz diff --git a/stb.spec b/stb.spec new file mode 100644 index 0000000..189323b --- /dev/null +++ b/stb.spec @@ -0,0 +1,872 @@ +%global commit 8b5f1f37b5b75829fc72d38e7b5d4bcbf8a26d55 + +# We choose not to package the “stb_include” library (stb_include.h) because, +# during the package review, it was observed that it follows coding practices +# that make it dangerous to use on untrusted inputs, including but not limited +# to: +# +# - It uses of strcat/strcpy into a fixed-length buffer that is assumed (but +# not proven) to be large enough for all possible uses +# - It ignores I/O errors (possibly leading to undefined behavior from reading +# uninitialized memory), and so on. Making it +# +# A substantial rewrite would be required to mitigate these concerns. If a +# request for this library arises, this decision may be revisited, or the +# necessary rewrite may be done and offered upstream. For now, we omit the +# library and expect it will not be missed. +%bcond_with stb_include + +Name: stb +# While the individual header-only libraries are versioned, the overall +# collection is not, and there are no releases. See: +# https://github.com/nothings/stb/issues/359 +# https://github.com/nothings/stb/issues/1101 +%global snapinfo .20220908git8b5f1f3 +Version: 0%{snapinfo} +Release: 0.4 +Summary: Single-file public domain libraries for C/C++ + +# See LICENSE. +License: MIT OR Unlicense +# Additionally, the following are under different terms, but are not used; to +# make certain, they are removed in %%prep. +# +# - deprecated/rrsprintf.h, tests/caveview/stb_gl.h, and +# tests/caveview/win32/SDL_windows_main.c are Public Domain +# - tests/caveview/glext.h is MIT (only) +URL: https://github.com/nothings/stb +Source0: %{url}/archive/%{commit}/stb-%{commit}.tar.gz + +# Fix undefined behavior from array “shape-punning” +# https://github.com/nothings/stb/pull/1194 +Patch01: 1194.patch + +# Fix misleading indentation in stb_divide.h +# https://github.com/nothings/stb/pull/1195 +Patch02: 1195.patch + +# Trivial fix for array-in-structure initialization (missing braces warning) +# https://github.com/nothings/stb/pull/1196 +Patch03: 1196.patch + +# Fix signature of dummy realloc() for STB_VORBIS_NO_CRT +# https://github.com/nothings/stb/pull/1198 +Patch04: 1198.patch + +# Candidate fix for: +# https://nvd.nist.gov/vuln/detail/CVE-2021-42715 +# +# In stb_image's HDR reader, loading a specially constructed invalid HDR file +# can result in an infinite loop within the RLE decoder +# https://github.com/nothings/stb/issues/1224 +# +# ---- +# +# Additionally, this is a candidate fix for: +# https://nvd.nist.gov/vuln/detail/CVE-2021-42716 +# +# stbi__pnm_load heap-buffer-overflow bug +# https://github.com/nothings/stb/issues/1166 +# +# In stb_image's PNM reader, loading a specially constructed valid 16-bit PGM +# file with 4 channels can cause a crash due to an out-of-bounds read +# https://github.com/nothings/stb/issues/1225 +# +# ---- +# +# Fixes a crash and an infinite loop in stb_image that could occur with +# specially constructed PGM and HDR files +# https://github.com/nothings/stb/pull/1223 +Patch05: 1223.patch + +# Forward declare stbhw__process struct to fix warnings +# https://github.com/nothings/stb/pull/1225 +# +# We don’t see these warnings in the “compile tests”, but we can reproduce them +# by manually compiling tests/herringbone_map.c; a real user of the +# stb_herringbone_wang_tile library would encounter them; and inspection of the +# patch shows it to be correct. +Patch06: 1236.patch + +# Candidate fix for: +# https://nvd.nist.gov/vuln/detail/CVE-2022-28041 +# +# stb_image.h v2.27 was discovered to contain an integer overflow via the +# function stbi__jpeg_decode_block_prog_dc. This vulnerability allows attackers +# to cause a Denial of Service (DoS) via unspecified vectors. +# +# UBSAN: integer overflow +# https://github.com/nothings/stb/issues/1292 +# +# ---- +# +# Additional stb_image fixes for bugs from ossfuzz and issues 1289, 1291, 1292, +# and 1293 +# https://github.com/nothings/stb/pull/1297 +Patch07: 1297.patch + +# stb_image PNG reader: Adds checks for invalid DEFLATE codes, fixing an +# infinite loop found by ossfuzz. +# https://github.com/nothings/stb/pull/1230 +# Fixes: +# Issue 24232: stb:stb_png_read_fuzzer: Timeout in stb_png_read_fuzzer +# https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=24232&q=proj%3Dstb +Patch08: 1230.patch + +%global stb_c_lexer_version 0.12 +%global stb_connected_components_version 0.96 +%global stb_divide_version 0.94 +%global stb_ds_version 0.67 +%global stb_dxt_version 1.12 +%global stb_easy_font_version 1.1 +%global stb_herringbone_wang_tile_version 0.7 +%global stb_hexwave_version 0.5 +%global stb_image_version 2.27 +%global stb_image_resize_version 0.97 +%global stb_image_write_version 1.16 +%global stb_include_version 0.2 +%global stb_leakcheck_version 0.6 +%global stb_perlin_version 0.5 +%global stb_rect_pack_version 1.1 +%global stb_sprintf_version 1.10 +%global stb_textedit_version 1.14 +%global stb_tilemap_editor_version 0.42 +%global stb_truetype_version 1.26 +%global stb_vorbis_version 1.22 +%global stb_voxel_render_version 0.89 + +BuildRequires: gcc +BuildRequires: gcc-c++ +BuildRequires: make + +BuildRequires: ImageMagick + +# No compiled binaries are installed, so this would be empty. +%global debug_package %{nil} + +%description +%{summary}. + + +%package devel +Summary: Development files for stb + +# Dependent packages should prefer to BuildRequire the -static packages for the +# specific stb libraries they use. +Provides: stb-static = %{version}-%{release} + +Requires: stb_c_lexer-devel%{?_isa} = %{stb_c_lexer_version}%{snapinfo}-%{release} +Requires: stb_c_lexer-static = %{stb_c_lexer_version}%{snapinfo}-%{release} +Requires: stb_connected_components-devel%{?_isa} = %{stb_connected_components_version}%{snapinfo}-%{release} +Requires: stb_connected_components-static = %{stb_connected_components_version}%{snapinfo}-%{release} +Requires: stb_divide-devel%{?_isa} = %{stb_divide_version}%{snapinfo}-%{release} +Requires: stb_divide-static = %{stb_divide_version}%{snapinfo}-%{release} +Requires: stb_ds-devel%{?_isa} = %{stb_ds_version}%{snapinfo}-%{release} +Requires: stb_ds-static = %{stb_ds_version}%{snapinfo}-%{release} +Requires: stb_dxt-devel%{?_isa} = %{stb_dxt_version}%{snapinfo}-%{release} +Requires: stb_dxt-static = %{stb_dxt_version}%{snapinfo}-%{release} +Requires: stb_easy_font-devel%{?_isa} = %{stb_easy_font_version}%{snapinfo}-%{release} +Requires: stb_easy_font-static = %{stb_easy_font_version}%{snapinfo}-%{release} +Requires: stb_herringbone_wang_tile-devel%{?_isa} = %{stb_herringbone_wang_tile_version}%{snapinfo}-%{release} +Requires: stb_herringbone_wang_tile-static = %{stb_herringbone_wang_tile_version}%{snapinfo}-%{release} +Requires: stb_hexwave-devel%{?_isa} = %{stb_hexwave_version}%{snapinfo}-%{release} +Requires: stb_hexwave-static = %{stb_hexwave_version}%{snapinfo}-%{release} +Requires: stb_image-devel%{?_isa} = %{stb_image_version}%{snapinfo}-%{release} +Requires: stb_image-static = %{stb_image_version}%{snapinfo}-%{release} +Requires: stb_image_resize-devel%{?_isa} = %{stb_image_resize_version}%{snapinfo}-%{release} +Requires: stb_image_resize-static = %{stb_image_resize_version}%{snapinfo}-%{release} +Requires: stb_image_write-devel%{?_isa} = %{stb_image_write_version}%{snapinfo}-%{release} +Requires: stb_image_write-static = %{stb_image_write_version}%{snapinfo}-%{release} +%if %{with stb_include} +Requires: stb_include-devel%{?_isa} = %{stb_include_version}%{snapinfo}-%{release} +Requires: stb_include-static = %{stb_include_version}%{snapinfo}-%{release} +%endif +Requires: stb_leakcheck-devel%{?_isa} = %{stb_leakcheck_version}%{snapinfo}-%{release} +Requires: stb_leakcheck-static = %{stb_leakcheck_version}%{snapinfo}-%{release} +Requires: stb_perlin-devel%{?_isa} = %{stb_perlin_version}%{snapinfo}-%{release} +Requires: stb_perlin-static = %{stb_perlin_version}%{snapinfo}-%{release} +Requires: stb_rect_pack-devel%{?_isa} = %{stb_rect_pack_version}%{snapinfo}-%{release} +Requires: stb_rect_pack-static = %{stb_rect_pack_version}%{snapinfo}-%{release} +Requires: stb_sprintf-devel%{?_isa} = %{stb_sprintf_version}%{snapinfo}-%{release} +Requires: stb_sprintf-static = %{stb_sprintf_version}%{snapinfo}-%{release} +Requires: stb_textedit-devel%{?_isa} = %{stb_textedit_version}%{snapinfo}-%{release} +Requires: stb_textedit-static = %{stb_textedit_version}%{snapinfo}-%{release} +Requires: stb_tilemap_editor-devel%{?_isa} = %{stb_tilemap_editor_version}%{snapinfo}-%{release} +Requires: stb_tilemap_editor-static = %{stb_tilemap_editor_version}%{snapinfo}-%{release} +Requires: stb_truetype-devel%{?_isa} = %{stb_truetype_version}%{snapinfo}-%{release} +Requires: stb_truetype-static = %{stb_truetype_version}%{snapinfo}-%{release} +Requires: stb_vorbis-devel%{?_isa} = %{stb_vorbis_version}%{snapinfo}-%{release} +Requires: stb_vorbis-static = %{stb_vorbis_version}%{snapinfo}-%{release} +Requires: stb_voxel_render-devel%{?_isa} = %{stb_voxel_render_version}%{snapinfo}-%{release} +Requires: stb_voxel_render-static = %{stb_voxel_render_version}%{snapinfo}-%{release} + +%description devel +The stb-devel package contains libraries and header files for developing +applications that use stb. + +This is a metapackage that requires the -devel packages for all stb libraries. + + +%package -n stb_c_lexer-devel +Summary: Simplify writing parsers for C-like languages +Version: %{stb_c_lexer_version}%{snapinfo} + +Provides: stb_c_lexer-static = %{stb_c_lexer_version}%{snapinfo}-%{release} + +%description -n stb_c_lexer-devel +Lexer for making little C-like languages with recursive-descent parsers. + + +%package -n stb_connected_components-devel +Summary: Incrementally compute reachability on grids +Version: %{stb_connected_components_version}%{snapinfo} + +Provides: stb_connected_components-static = %{stb_connected_components_version}%{snapinfo}-%{release} + +%description -n stb_connected_components-devel +Finds connected components on 2D grids for testing reachability between two +points, with fast updates when changing reachability (e.g. on one machine it +was typically 0.2ms w/ 1024x1024 grid). Each grid square must be “open” or +“closed” (traversable or untraversable), and grid squares are only connected to +their orthogonal neighbors, not diagonally. + + +%package -n stb_divide-devel +Summary: More useful 32-bit modulus e.g. “Euclidean divide” +Version: %{stb_divide_version}%{snapinfo} + +Provides: stb_divide-static = %{stb_divide_version}%{snapinfo}-%{release} + +%description -n stb_divide-devel +This file provides three different consistent divide/mod pairs +implemented on top of arbitrary C/C++ division, including correct +handling of overflow of intermediate calculations: + + trunc: a/b truncates to 0, a%b has same sign as a + floor: a/b truncates to -inf, a%b has same sign as b + eucl: a/b truncates to sign(b)*inf, a%b is non-negative + + +%package -n stb_ds-devel +Summary: Typesafe dynamic array and hash tables for C, will compile in C++ +Version: %{stb_ds_version}%{snapinfo} + +Provides: stb_ds-static = %{stb_ds_version}%{snapinfo}-%{release} + +%description -n stb_ds-devel +This is a single-header-file library that provides easy-to-use dynamic arrays +and hash tables for C (also works in C++). + +For a gentle introduction: https://nothings.org/stb_ds + + +%package -n stb_dxt-devel +Summary: Fabian “ryg” Giesen’s real-time DXT compressor +Version: %{stb_dxt_version}%{snapinfo} + +Provides: stb_dxt-static = %{stb_dxt_version}%{snapinfo}-%{release} + +%description -n stb_dxt-devel +DXT1/DXT5 compressor. + + +%package -n stb_easy_font-devel +Summary: Quick-and-dirty easy-to-deploy bitmap font for printing frame rate, etc +Version: %{stb_easy_font_version}%{snapinfo} + +Provides: stb_easy_font-static = %{stb_easy_font_version}%{snapinfo}-%{release} + +%description -n stb_easy_font-devel + Easy-to-deploy, + reasonably compact, + extremely inefficient performance-wise, + crappy-looking, + ASCII-only, + bitmap font for use in 3D APIs. + +Intended for when you just want to get some text displaying in a 3D app as +quickly as possible. + +Doesn’t use any textures, instead builds characters out of quads. + + +%package -n stb_herringbone_wang_tile-devel +Summary: Herringbone Wang tile map generator +Version: %{stb_herringbone_wang_tile_version}%{snapinfo} + +Provides: stb_herringbone_wang_tile-static = %{stb_herringbone_wang_tile_version}%{snapinfo}-%{release} + +%description -n stb_herringbone_wang_tile-devel +This library is an SDK for Herringbone Wang Tile generation: + + http://nothings.org/gamedev/herringbone + +The core design is that you use this library offline to generate a “template” +of the tiles you’ll create. You then edit those tiles, then load the created +tile image file back into this library and use it at runtime to generate +“maps”. + +You cannot load arbitrary tile image files with this library; it is only +designed to load image files made from the template it created. It stores a +binary description of the tile sizes & constraints in a few pixels, and uses +those to recover the rules, rather than trying to parse the tiles themselves. + +You *can* use this library to generate from arbitrary tile sets, but only by +loading the tile set and specifying the constraints explicitly yourself. + + +%package -n stb_hexwave-devel +Summary: Audio waveform synthesizer +Version: %{stb_hexwave_version}%{snapinfo} + +Provides: stb_hexwave-static = %{stb_hexwave_version}%{snapinfo}-%{release} + +%description -n stb_hexwave-devel +A flexible anti-aliased (bandlimited) digital audio oscillator. + +This library generates waveforms of a variety of shapes made of line segments. +It does not do envelopes, LFO effects, etc.; it merely tries to solve the +problem of generating an artifact-free morphable digital waveform with a +variety of spectra, and leaves it to the user to rescale the waveform and mix +multiple voices, etc. + + +%package -n stb_image-devel +Summary: Image loading/decoding from file/memory: JPG, PNG, TGA, BMP, PSD, GIF, HDR, PIC +Version: %{stb_image_version}%{snapinfo} + +Provides: stb_image-static = %{stb_image_version}%{snapinfo}-%{release} + +%description -n stb_image-devel +%{summary}. + +Primarily of interest to game developers and other people who can avoid +problematic images and only need the trivial interface. + + +%package -n stb_image_resize-devel +Summary: Resize images larger/smaller with good quality +Version: %{stb_image_resize_version}%{snapinfo} + +Provides: stb_image_resize-static = %{stb_image_resize_version}%{snapinfo}-%{release} + +%description -n stb_image_resize-devel +Image resizing. + +Written with emphasis on usability, portability, and efficiency. (No SIMD or +threads, so it be easily outperformed by libs that use those.) Only scaling and +translation is supported, no rotations or shears. Easy API downsamples +w/Mitchell filter, upsamples w/cubic interpolation. + + +%package -n stb_image_write-devel +Summary: Image writing to disk: PNG, TGA, BMP +Version: %{stb_image_write_version}%{snapinfo} + +Provides: stb_image_write-static = %{stb_image_write_version}%{snapinfo}-%{release} + +%description -n stb_image_write-devel +This header file is a library for writing images to C stdio or a callback. + +The PNG output is not optimal; it is 20-50%% larger than the file written by a +decent optimizing implementation; though providing a custom zlib compress +function (see STBIW_ZLIB_COMPRESS) can mitigate that. This library is designed +for source code compactness and simplicity, not optimal image file size or +run-time performance. + + +%if %{with stb_include} +%package -n stb_include-devel +Summary: Implement recursive #include support, particularly for GLSL +Version: %{stb_include_version}%{snapinfo} + +Provides: stb_include-static = %{stb_include_version}%{snapinfo}-%{release} + +%description -n stb_include-devel +This program parses a string and replaces lines of the form + #include "foo" +with the contents of a file named "foo". It also embeds the appropriate #line +directives. Note that all include files must reside in the location specified +in the path passed to the API; it does not check multiple directories. + +If the string contains a line of the form + #inject +then it will be replaced with the contents of the string ‘inject’ passed to the +API. +%endif + + +%package -n stb_leakcheck-devel +Summary: Quick-and-dirty malloc/free leak-checking +Version: %{stb_leakcheck_version}%{snapinfo} + +Provides: stb_leakcheck-static = %{stb_leakcheck_version}%{snapinfo}-%{release} + +%description -n stb_leakcheck-devel +%{summary}. + + +%package -n stb_perlin-devel +Summary: Perlin’s revised simplex noise w/ different seeds +Version: %{stb_perlin_version}%{snapinfo} + +Provides: stb_perlin-static = %{stb_perlin_version}%{snapinfo}-%{release} + +%description -n stb_perlin-devel +%{summary}. + + +%package -n stb_rect_pack-devel +Summary: Simple 2D rectangle packer with decent quality +Version: %{stb_rect_pack_version}%{snapinfo} + +Provides: stb_rect_pack-static = %{stb_rect_pack_version}%{snapinfo}-%{release} + +%description -n stb_rect_pack-devel +Useful for e.g. packing rectangular textures into an atlas. Does not do +rotation. + +Not necessarily the awesomest packing method, but better than the totally naive +one in stb_truetype (which is primarily what this is meant to replace). + +No memory allocations; uses qsort() and assert() from stdlib. Can override +those by defining STBRP_SORT and STBRP_ASSERT. + +This library currently uses the Skyline Bottom-Left algorithm. + +Please note: better rectangle packers are welcome! Please implement them to the +same API, but with a different init function. + + +%package -n stb_sprintf-devel +Summary: Fast sprintf, snprintf for C/C++ +Version: %{stb_sprintf_version}%{snapinfo} + +Provides: stb_sprintf-static = %{stb_sprintf_version}%{snapinfo}-%{release} + +%description -n stb_sprintf-devel +This is a full sprintf replacement that supports everything that the C runtime +sprintfs support, including float/double, 64-bit integers, hex floats, field +parameters (%%*.*d stuff), length reads backs, etc. + +Why would you need this if sprintf already exists? Well, first off, it’s *much* +faster (see below). It’s also much smaller than the CRT versions +code-space-wise. We’ve also added some simple improvements that are super handy +(commas in thousands, callbacks at buffer full, for example). Finally, the +format strings for MSVC and GCC differ for 64-bit integers (among other small +things), so this lets you use the same format strings in cross platform code. + +It uses the standard single file trick of being both the header file and the +source itself. If you just include it normally, you just get the header file +function definitions. To get the code, you include it from a C or C++ file and +define STB_SPRINTF_IMPLEMENTATION first. + +It only uses va_args macros from the C runtime to do its work. It does cast +doubles to S64s and shifts and divides U64s, which does drag in CRT code on +most platforms. + +It compiles to roughly 8K with float support, and 4K without. As a comparison, +when using MSVC static libs, calling sprintf drags in 16K. + + +%package -n stb_textedit-devel +Summary: Guts of a text editor for games etc., implementing them from scratch +Version: %{stb_textedit_version}%{snapinfo} + +Provides: stb_textedit-static = %{stb_textedit_version}%{snapinfo}-%{release} + +%description -n stb_textedit-devel +This C header file implements the guts of a multi-line text-editing widget; you +implement display, word-wrapping, and low-level string insertion/deletion, and +stb_textedit will map user inputs into insertions & deletions, plus updates to +the cursor position, selection state, and undo state. + +It is intended for use in games and other systems that need to build their own +custom widgets and which do not have heavy text-editing requirements (this +library is not recommended for use for editing large texts, as its performance +does not scale and it has limited undo). + +Non-trivial behaviors are modelled after Windows text controls. + + +%package -n stb_tilemap_editor-devel +Summary: Embeddable tilemap editor +Version: %{stb_tilemap_editor_version}%{snapinfo} + +Provides: stb_tilemap_editor-static = %{stb_tilemap_editor_version}%{snapinfo}-%{release} + +%description -n stb_tilemap_editor-devel +Embeddable tilemap editor for C/C++. + + +%package -n stb_truetype-devel +Summary: Parse, decode, and rasterize characters from TrueType fonts +Version: %{stb_truetype_version}%{snapinfo} + +Provides: stb_truetype-static = %{stb_truetype_version}%{snapinfo}-%{release} + +%description -n stb_truetype-devel +%{summary}. +======================================================================= + + NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES + +This library does no range checking of the offsets found in the file, +meaning an attacker can use it to read arbitrary memory. + +======================================================================= + +This library processes TrueType files: + • parse files + • extract glyph metrics + • extract glyph shapes + • render glyphs to one-channel bitmaps with antialiasing (box filter) + • render glyphs to one-channel SDF bitmaps (signed-distance field/function) + + +%package -n stb_vorbis-devel +Summary: Decode Ogg Vorbis files from file/memory to float/16-bit signed output +Version: %{stb_vorbis_version}%{snapinfo} + +Provides: stb_vorbis-static = %{stb_vorbis_version}%{snapinfo}-%{release} + +%description -n stb_vorbis-devel +Ogg Vorbis audio decoder. + + +%package -n stb_voxel_render-devel +Summary: Helps render large-scale “voxel” worlds for games +Version: %{stb_voxel_render_version}%{snapinfo} + +Provides: stb_voxel_render-static = %{stb_voxel_render_version}%{snapinfo}-%{release} + +%description -n stb_voxel_render-devel +This library helps render large-scale “voxel” worlds for games, in this case, +one with blocks that can have textures and that can also be a few shapes other +than cubes. + + Video introduction: + http://www.youtube.com/watch?v=2vnTtiLrV1w + + Minecraft-viewer sample app (not very simple though): + http://github.com/nothings/stb/tree/master/tests/caveview + +It works by creating triangle meshes. The library includes + + - converter from dense 3D arrays of block info to vertex mesh + - vertex & fragment shaders for the vertex mesh + - assistance in setting up shader state + +For portability, none of the library code actually accesses the 3D graphics +API. (At the moment, it’s not actually portable since the shaders are GLSL +only, but patches are welcome.) + +You have to do all the caching and tracking of vertex buffers yourself. +However, you could also try making a game with a small enough world that it’s +fully loaded rather than streaming. Currently the preferred vertex format is 20 +bytes per quad. There are designs to allow much more compact formats with a +slight reduction in shader features, but no roadmap for actually implementing +them. + +%package_help + +%prep +%autosetup -n stb-%{commit} -p1 + +# Append to OS build flags rather than overriding them +# +# Instead of hard-coding C++ standard and calling the C compiler, defer to the +# default and call the C++ compiler. +# +# When upstream says CPPFLAGS, they +# mean C++ flags, i.e. CXXFLAGS, not “C PreProcessor Flags” as is common in +# autoconf-influenced projects. +sed -r -i \ + -e 's/([[:alpha:]]+FLAGS[[:blank:]]*)=/\1+=/' \ + -e 's/(\$\(CC\))(.*)-std=[^[:blank:]]+/\$\(CXX\)\2/' \ + -e 's/CPPFLAGS/CXXFLAGS/' tests/Makefile + +# Add a dummy main(); how does this one work upstream?! Note that omitting +# parameter names is a C++-ism. +echo 'int main(int, char *[]) { return 0; }' >> tests/test_cpp_compilation.cpp + +# Remove any pre-compiled Windows executables +find . -type f -name '*.exe' -print -delete + +# Remove some unused parts of the source tree that could contribute different +# (but acceptable) license terms if they were used—just to prove that we do not +# use them. +rm -rvf deprecated tests/caveview + +%if %{without stb_include} +sed -r -i '/#include[[:blank:]]+"stb_include.h"/d' tests/test_c_compilation.c +%endif + + +%build +# There is no compiled code to install, since all stb libraries are +# header-only. We do need to build the tests. +%set_build_flags +%make_build -C tests + + +%install +# Installing a “.c” file in /usr/include is unconventional, but correct and not +# unprecedented. Any .c file in stb is meant to be #include’d and used as a +# header-only library, just as the “.h” files in the other stb libraries. The +# only difference is the file extension. +# +# Since these are designed to be copied into dependent package source trees, +# there is no convention on include paths. Most projects end up using “#include +# ” or “#include ”, so we install to +# %%{_includedir}/stb/stb_foo.h and %%{_includedir}/stb_foo.h, with the latter +# as a symbolic link to the former. This means most projects can unbundle the +# library without having to make their own local symlinks or patch their +# sources. +install -t '%{buildroot}%{_includedir}/stb' -p -m 0644 -D stb_*.h stb_*.c +%if %{without stb_include} +rm -vf '%{buildroot}%{_includedir}/stb/stb_include.h' +%endif +pushd '%{buildroot}%{_includedir}' +ln -sv stb/stb_*.? . +popd + + +%check +# The tests in tests/Makefile are largely just “will it compile” tests. There +# are some other files with main routines under tests/, but they have neither +# Makefile targets nor instructions on how to build or run them or what to +# expect them to do. We don’t dig through these sources to try to guess what to +# do with them. + +# We can run image_write_test and confirm the output images are valid. +rm -vf output +mkdir -p output +./tests/image_write_test +# We assume that if ImageMagick can read the output images, then they are valid. +for img in wr6x5_flip.bmp wr6x5_flip.jpg wr6x5_flip.tga wr6x5_regular.hdr \ + wr6x5_regular.png wr6x5_flip.hdr wr6x5_flip.png wr6x5_regular.bmp \ + wr6x5_regular.jpg wr6x5_regular.tga +do + convert "output/${img}" 'output/dummy.bmp' +done + +# As a sanity check, verify that all of the subpackage version numbers appear +# in the corresponding headers. +while read -r version header +do + %{?!with_stb_include:if [ "${header}" = 'stb_include.h' ]; then continue; fi} + # The minor version may be zero-padded in the header. + grep -E "$( + echo "${version}" | + sed -r 's/([[:digit:]]+)\.([[:digit:]]+)/\\bv\1\\.0*\2\\b/' + )" "%{buildroot}%{_includedir}/${header}" >/dev/null +done <<'EOF' +%{stb_c_lexer_version} stb_c_lexer.h +%{stb_connected_components_version} stb_connected_components.h +%{stb_divide_version} stb_divide.h +%{stb_ds_version} stb_ds.h +%{stb_dxt_version} stb_dxt.h +%{stb_easy_font_version} stb_easy_font.h +%{stb_herringbone_wang_tile_version} stb_herringbone_wang_tile.h +%{stb_hexwave_version} stb_hexwave.h +%{stb_image_version} stb_image.h +%{stb_image_resize_version} stb_image_resize.h +%{stb_image_write_version} stb_image_write.h +%{stb_include_version} stb_include.h +%{stb_leakcheck_version} stb_leakcheck.h +%{stb_perlin_version} stb_perlin.h +%{stb_rect_pack_version} stb_rect_pack.h +%{stb_sprintf_version} stb_sprintf.h +%{stb_textedit_version} stb_textedit.h +%{stb_tilemap_editor_version} stb_tilemap_editor.h +%{stb_truetype_version} stb_truetype.h +%{stb_vorbis_version} stb_vorbis.c +%{stb_voxel_render_version} stb_voxel_render.h +EOF + + +%files devel +# Empty metapackage + + +%files help +%license LICENSE +%doc docs +%doc README.md +%doc tests/tilemap_editor_integration_example.c + + +%files -n stb_c_lexer-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_c_lexer.h +%{_includedir}/stb_c_lexer.h + + +%files -n stb_connected_components-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_connected_components.h +%{_includedir}/stb_connected_components.h + + +%files -n stb_divide-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_divide.h +%{_includedir}/stb_divide.h + + +%files -n stb_ds-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_ds.h +%{_includedir}/stb_ds.h + + +%files -n stb_dxt-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_dxt.h +%{_includedir}/stb_dxt.h + + +%files -n stb_easy_font-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_easy_font.h +%{_includedir}/stb_easy_font.h + + +%files -n stb_herringbone_wang_tile-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_herringbone_wang_tile.h +%{_includedir}/stb_herringbone_wang_tile.h + + +%files -n stb_hexwave-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_hexwave.h +%{_includedir}/stb_hexwave.h + + +%files -n stb_image-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_image.h +%{_includedir}/stb_image.h + + +%files -n stb_image_resize-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_image_resize.h +%{_includedir}/stb_image_resize.h + + +%files -n stb_image_write-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_image_write.h +%{_includedir}/stb_image_write.h + + +%if %{with stb_include} +%files -n stb_include-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_include.h +%{_includedir}/stb_include.h +%endif + + +%files -n stb_leakcheck-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_leakcheck.h +%{_includedir}/stb_leakcheck.h + + +%files -n stb_perlin-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_perlin.h +%{_includedir}/stb_perlin.h + + +%files -n stb_rect_pack-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_rect_pack.h +%{_includedir}/stb_rect_pack.h + + +%files -n stb_sprintf-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_sprintf.h +%{_includedir}/stb_sprintf.h + + +%files -n stb_textedit-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_textedit.h +%{_includedir}/stb_textedit.h + + +%files -n stb_tilemap_editor-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_tilemap_editor.h +%{_includedir}/stb_tilemap_editor.h + + +%files -n stb_truetype-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_truetype.h +%{_includedir}/stb_truetype.h + + +%files -n stb_vorbis-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_vorbis.c +%{_includedir}/stb_vorbis.c + + +%files -n stb_voxel_render-devel +%license LICENSE +# Directory has shared ownership across stb subpackages: +%dir %{_includedir}/stb +%{_includedir}/stb/stb_voxel_render.h +%{_includedir}/stb_voxel_render.h + + +%changelog +* Mon Dec 5 2022 peijiankang - 0.20220908git8b5f1f3-0.4 +- Init package for openEuler -- cgit v1.2.3